From 722b5eab9deeac05c589fc07641efa060b0e7efb Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 12 Jul 2025 10:41:30 -0400 Subject: [PATCH 01/79] [spr] initial version Created using spr 1.3.6-beta.1 --- .vscode/extensions.json | 17 +- eslint.config.mjs | 1 + mise.toml | 22 +- notes.md | 5 +- package.json | 5 + src/extension/keybindings/index.ts | 63 +++ src/presets/larkin.toml | 6 +- src/rust/parsing/Cargo.lock | 722 +++++++++++++++++++++++++++++ src/rust/parsing/Cargo.toml | 16 + src/rust/parsing/src/command.rs | 705 ++++++++++++++++++++++++++++ src/rust/parsing/src/lib.rs | 8 + tsconfig.json | 2 +- 12 files changed, 1547 insertions(+), 25 deletions(-) create mode 100644 src/rust/parsing/Cargo.lock create mode 100644 src/rust/parsing/Cargo.toml create mode 100644 src/rust/parsing/src/command.rs create mode 100644 src/rust/parsing/src/lib.rs diff --git a/.vscode/extensions.json b/.vscode/extensions.json index ca41ef1a..95354a43 100644 --- a/.vscode/extensions.json +++ b/.vscode/extensions.json @@ -1,10 +1,11 @@ { - // See http://go.microsoft.com/fwlink/?LinkId=827846 - // for the documentation about the extensions.json format - "recommendations": [ - "dbaeumer.vscode-eslint", - "connor4312.esbuild-problem-matchers", - "ms-vscode.extension-test-runner", - "ms-playwright.playwright", - ] + // See http://go.microsoft.com/fwlink/?LinkId=827846 + // for the documentation about the extensions.json format + "recommendations": [ + "dbaeumer.vscode-eslint", + "connor4312.esbuild-problem-matchers", + "ms-vscode.extension-test-runner", + "ms-playwright.playwright", + "rust-lang.rust-analyzer", + ] } diff --git a/eslint.config.mjs b/eslint.config.mjs index 480d89d2..d9c64b45 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -14,6 +14,7 @@ export default defineConfig([ 'src/rust/parsing/lib/**/*.{js,ts,t.ds}', 'out/**/*.js', 'src/oldtest/**', + 'src/oldparsing/**', 'docs/.vitepress/theme/**/*.{js,ts,t.ds}', ]), { diff --git a/mise.toml b/mise.toml index 378a0a87..a9117c54 100644 --- a/mise.toml +++ b/mise.toml @@ -4,7 +4,7 @@ node = "20" "npm:pnpm" = "10.12.4" "npm:typescript" = "5.8.3" "npm:vsce" = "2.15" -rust = { version = "1.87", targets = "wasm32-unknown-unknown" } +rust = { version = "1.88", targets = "wasm32-unknown-unknown" } watchexec = "2.3.2" "ubi:haberdashpi/simple-src-docs" = "0.6.0" "npm:c8" = "latest" @@ -19,22 +19,22 @@ run = 'pnpm exec eslint src' [tasks.check-types] run = 'tsc --noEmit --project tsconfig.json' -# [tasks.build-rust] -# sources = ['src/rust/parsing/src/**/*.rs', 'src/rust/parsing/Cargo.toml'] -# outputs = ['out/**/*.wasm', 'src/rust/parsing/lib/*'] -# dir = 'src/rust/parsing' -# run = [ -# 'wasm-pack build --target web --out-dir lib', -# 'cp lib/parsing_bg.wasm ../../../out/parsing_bg.wasm', -# ] +[tasks.build-rust] +sources = ['src/rust/parsing/src/**/*.rs', 'src/rust/parsing/Cargo.toml'] +outputs = ['out/**/*.wasm', 'src/rust/parsing/lib/*'] +dir = 'src/rust/parsing' +run = [ + 'wasm-pack build --target web --out-dir lib', + 'cp lib/parsing_bg.wasm ../../../out/parsing_bg.wasm', +] [tasks.build] -depends = ['check-types', 'lint'] #, 'build-rust'] +depends = ['check-types', 'lint', 'build-rust'] sources = ['src/**/*.ts'] run = ['pwd', 'node esbuild.mjs'] [tasks.package] -depends = ['check-types', 'lint'] #, 'build-rust'] +depends = ['check-types', 'lint', 'build-rust'] sources = ['src/**/*.ts'] run = [ 'node esbuild.mjs --release', diff --git a/notes.md b/notes.md index 032022a5..3796742f 100644 --- a/notes.md +++ b/notes.md @@ -62,11 +62,12 @@ Integration test debugging: 2. eliminate/cleanup functionality I don't have good coverage for - [X] eliminate elaborate loading UI - [X] don't auto load documentation - - [ ] don't automatically offer to install extensions - - [ ] add buttons to info message to show documentation + - [X] don't automatically offer to install extensions + - [X] add buttons to info message to show documentation 3. Refactor parsing to rust a. in this early phase, we don't worry too much about providing detailed error messages (if there are easy things to do here we can do them, but no UX work, etc...) + - [ ] start by implementing parsing of `[[bind]]` 4. Move palette from quick pick to tree view - [ ] get a simple tree view working (just show one item) - [ ] get tree view to show palette items diff --git a/package.json b/package.json index 2a7c4283..a445187e 100644 --- a/package.json +++ b/package.json @@ -23,6 +23,11 @@ "browser": "./out/browser/index.js", "contributes": { "commands": [ + { + "command": "master-key.test-rust", + "category": "Master Key", + "title": "Test Rust" + }, { "command": "master-key.activateBindings", "category": "Master Key", diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index a9299a38..b04fa483 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -25,6 +25,9 @@ import { toLayoutIndependentString } from './layout'; import JSONC from 'jsonc-simple-parser'; import TOML from 'smol-toml'; +// run `mise build-rust` to create this auto generated source file +import initParsing, { simple, debug_parse_command } from '../../rust/parsing/lib'; + //////////////////////////////////////////////////////////////////////////////////////////// // Keybinding Generation @@ -643,6 +646,66 @@ export async function activate(context: vscode.ExtensionContext) { updateConfig(undefined, false); vscode.workspace.onDidChangeConfiguration(updateConfig); + // initialize rust WASM module for parsing keybinding files + const filename = vscode.Uri.joinPath(context.extensionUri, 'out', 'parsing_bg.wasm'); + const bits = await vscode.workspace.fs.readFile(filename); + await initParsing(bits); + + context.subscriptions.push( + vscode.commands.registerCommand('master-key.test-rust', () => { + const parsing = debug_parse_command(` + command = "do" + args = { a = "2", b = 3 } + computedArgs = { c = "1+2" } + key = "a" + when = "joe > 1" + mode = "normal" + priority = 1 + defaults = "foo.bar" + foreach.index = [1,2,3] + prefixes = "c" + finalKey = true + computedRepeat = "2+c" + name = "foo" + description = "foo bar bin" + hideInPalette = false + hideInDocs = false + combinedName = "Up/down" + combinedKey = "A/B" + combinedDescription = "bla bla bla" + kind = "biz" + whenComputed = "f > 2" + `); + + vscode.window.showInformationMessage(`Rust says: + command: ${parsing.command} + args: ${parsing.args} + computedArgs: ${parsing.computedArgs} + key: ${parsing.key} + when: ${parsing.when} + mode: ${parsing.mode} + priority: ${parsing.priority} + defaults: ${parsing.defaults} + foreach: ${parsing.foreach} + prefixes: ${parsing.prefixes} + finalKey: ${parsing.finalKey} + computedRepeat: ${parsing.computedRepeat} + name: ${parsing.name} + description: ${parsing.description} + hideInPalette: ${parsing.hideInPalette} + hideInDocs: ${parsing.hideInDocs} + combinedName: ${parsing.combinedName} + combinedKey: ${parsing.combinedKey} + combinedDescription: ${parsing.combinedDescription} + kind: ${parsing.kind} + whenComputed: ${parsing.whenComputed} + `); + const result = simple(); + vscode.window.showInformationMessage('Rust says: "' + result + '"'); + return result; + }), + ); + // TODO: add all user bindings /** * @userCommand activateBindings diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 773661b5..beefbe1a 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -166,7 +166,7 @@ combinedKey = "escape/ctrl+[" combinedName = "normal" combinedDescription = "Enter normal mode" key = "{{key}}" -mode = [] +mode = "{{all_modes}}" hideInPalette = true hideInDocs = false command = "master-key.enterNormal" @@ -183,7 +183,7 @@ hideInDocs = true when = "suggestWidgetVisible && editorTextFocus && !findWidgetVisible" command = "runCommands" args.commands = ["hideSuggestWidget", "master-key.enterNormal"] -mode = [] +mode = "{{all_modes}}" prefixes = "{{all_prefixes}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect @@ -2460,7 +2460,7 @@ key = "shift+ctrl+;" name = "palette" finalKey = false hideInPalette = true -mode = [] +mode = "{{all_modes}}" prefixes = "{{all_prefixes}}" description = """ show command suggestions within the context of the current mode and keybinding prefix diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock new file mode 100644 index 00000000..2d6528d7 --- /dev/null +++ b/src/rust/parsing/Cargo.lock @@ -0,0 +1,722 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aho-corasick" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +dependencies = [ + "memchr", +] + +[[package]] +name = "bumpalo" +version = "3.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" + +[[package]] +name = "cfg-if" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" + +[[package]] +name = "darling" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.20.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "form_urlencoded" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "hashbrown" +version = "0.15.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5" + +[[package]] +name = "icu_collections" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" + +[[package]] +name = "icu_properties" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "potential_utf", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" + +[[package]] +name = "icu_provider" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" +dependencies = [ + "displaydoc", + "icu_locale_core", + "stable_deref_trait", + "tinystr", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" + +[[package]] +name = "js-sys" +version = "0.3.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "litemap" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" + +[[package]] +name = "log" +version = "0.4.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" + +[[package]] +name = "memchr" +version = "2.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "parsing" +version = "0.1.0" +dependencies = [ + "lazy_static", + "regex", + "serde", + "serde-wasm-bindgen", + "toml", + "validator", + "wasm-bindgen", +] + +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "potential_utf" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" +dependencies = [ + "zerovec", +] + +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "regex" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" + +[[package]] +name = "rustversion" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d" + +[[package]] +name = "ryu" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" + +[[package]] +name = "serde" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde-wasm-bindgen" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b" +dependencies = [ + "js-sys", + "serde", + "wasm-bindgen", +] + +[[package]] +name = "serde_derive" +version = "1.0.219" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.140" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +dependencies = [ + "itoa", + "memchr", + "ryu", + "serde", +] + +[[package]] +name = "serde_spanned" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +dependencies = [ + "serde", +] + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "stable_deref_trait" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "2.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "tinystr" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "toml" +version = "0.8.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +dependencies = [ + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", +] + +[[package]] +name = "toml_datetime" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.22.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "toml_write", + "winnow", +] + +[[package]] +name = "toml_write" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" + +[[package]] +name = "unicode-ident" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" + +[[package]] +name = "url" +version = "2.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "validator" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43fb22e1a008ece370ce08a3e9e4447a910e92621bb49b85d6e48a45397e7cfa" +dependencies = [ + "idna", + "once_cell", + "regex", + "serde", + "serde_derive", + "serde_json", + "url", + "validator_derive", +] + +[[package]] +name = "validator_derive" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7df16e474ef958526d1205f6dda359fdfab79d9aa6d54bafcb92dcd07673dca" +dependencies = [ + "darling", + "once_cell", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6" +dependencies = [ + "bumpalo", + "log", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.100" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "winnow" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd" +dependencies = [ + "memchr", +] + +[[package]] +name = "writeable" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" + +[[package]] +name = "yoke" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" +dependencies = [ + "serde", + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "synstructure", +] + +[[package]] +name = "zerotrie" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml new file mode 100644 index 00000000..737aada9 --- /dev/null +++ b/src/rust/parsing/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "parsing" +version = "0.1.0" +edition = "2024" + +[dependencies] +lazy_static = "1.5.0" +regex = "1.11.1" +serde = { version = "1.0.219", features = ["derive"] } +serde-wasm-bindgen = "0.6.5" +toml = "0.8.23" +validator = { version = "0.20.0", features = ["derive"] } +wasm-bindgen = "0.2.100" + +[lib] +crate-type = ["cdylib"] diff --git a/src/rust/parsing/src/command.rs b/src/rust/parsing/src/command.rs new file mode 100644 index 00000000..a9606193 --- /dev/null +++ b/src/rust/parsing/src/command.rs @@ -0,0 +1,705 @@ +#![allow(non_snake_case)] + +use core::fmt; +use lazy_static::lazy_static; +use regex::Regex; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_wasm_bindgen; +use std::collections::HashMap; +use toml::Value; +use toml::map::Map; +use validator::{Validate, ValidationError}; +use wasm_bindgen::JsValue; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub fn debug_parse_command(command_str: &str) -> Result { + let result = toml::from_str::(command_str)?; + return match Command::new(result) { + Ok(x) => Ok(x), + Err(e) => Err(JsError::from(e)), + }; +} + +// ---------------------------------- +// Validate TOML table structure + +trait FoundError { + fn found_error(self) -> Result<(), T>; +} + +impl FoundError for Option { + fn found_error(self) -> Result<(), T> { + return match self { + Some(err) => Err(err), + None => Ok(()), + }; + } +} + +fn valid_json_array(values: &Vec) -> Result<(), ValidationError> { + return values + .iter() + .find_map(|x| match valid_json_value(x) { + Ok(()) => None, + Err(err) => Some(err), + }) + .found_error(); +} + +fn valid_json_object(kv: &toml::Table) -> Result<(), ValidationError> { + return kv + .iter() + .find_map(|(_, v)| match valid_json_value(v) { + Ok(()) => None, + Err(err) => Some(err), + }) + .found_error(); +} + +// we read in TOML values, but only want to accept JSON-valid values in some contexts +// (since that is what we'll be serializing out to) +fn valid_json_value(x: &Value) -> Result<(), ValidationError> { + match x { + Value::Integer(_) | Value::Float(_) | Value::Boolean(_) | Value::String(_) => { + return Ok(()); + } + Value::Datetime(_) => return Err(ValidationError::new("Unexpected datetime value")), + Value::Array(values) => return valid_json_array(values), + Value::Table(kv) => return valid_json_object(kv), + }; +} + +fn valid_json_array_object(kv: &toml::Table) -> Result<(), ValidationError> { + return kv + .iter() + .find_map(|(_, v)| match v { + Value::Array(_) => match valid_json_value(v) { + Ok(()) => None, + Err(err) => Some(err), + }, + _ => Some(ValidationError::new( + "Expected all object fields to be arrays", + )), + }) + .found_error(); +} + +trait Merging { + fn merge(self, default: T) -> T; + fn require(self) -> Result; +} + +#[derive(Default, Deserialize, PartialEq, Debug)] +#[serde(untagged)] +enum Plural { + #[default] + Zero, + One(T), + Many(Vec), +} + +impl Plural { + fn to_array(self) -> Vec { + return match self { + Plural::Zero => Vec::new(), + Plural::One(val) => vec![val], + Plural::Many(vals) => vals, + }; + } +} + +// required values are only required at the very end of parsing, once all known defaults +// have been resolved +#[derive(Default, Deserialize, Serialize, PartialEq, Debug)] +#[serde(untagged)] +enum Required { + #[default] + DefaultValue, + Value(T), +} + +impl Merging, T> for Required { + fn require(self) -> Result { + return match self { + Required::DefaultValue => { + Err(CommandValidationError::new("Missing required field".into())) + } + Required::Value(val) => Ok(val), + }; + } + fn merge(self, default: Self) -> Self { + match self { + Required::Value(_) => self, + Required::DefaultValue => default, + } + } +} + +fn default_mode() -> Plural { + return Plural::One("default".into()); +} + +lazy_static! { + static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); + static ref KEY_REGEXS: Vec = vec![ + Regex::new(r"(?i)f[1-9]").unwrap(), + Regex::new(r"(?i)f1[0-9]").unwrap(), + Regex::new(r"[a-z]").unwrap(), + Regex::new(r"[0-9]").unwrap(), + Regex::new(r"`").unwrap(), + Regex::new(r"-").unwrap(), + Regex::new(r"=").unwrap(), + Regex::new(r"\[").unwrap(), + Regex::new(r"\]").unwrap(), + Regex::new(r"\\").unwrap(), + Regex::new(r";").unwrap(), + Regex::new(r"'").unwrap(), + Regex::new(r",").unwrap(), + Regex::new(r"\.").unwrap(), + Regex::new(r"\/").unwrap(), + Regex::new(r"(?i)left").unwrap(), + Regex::new(r"(?i)up").unwrap(), + Regex::new(r"(?i)right").unwrap(), + Regex::new(r"(?i)down").unwrap(), + Regex::new(r"(?i)pageup").unwrap(), + Regex::new(r"(?i)pagedown").unwrap(), + Regex::new(r"(?i)end").unwrap(), + Regex::new(r"(?i)home").unwrap(), + Regex::new(r"(?i)tab").unwrap(), + Regex::new(r"(?i)enter").unwrap(), + Regex::new(r"(?i)escape").unwrap(), + Regex::new(r"(?i)space").unwrap(), + Regex::new(r"(?i)backspace").unwrap(), + Regex::new(r"(?i)delete").unwrap(), + Regex::new(r"(?i)pausebreak").unwrap(), + Regex::new(r"(?i)capslock").unwrap(), + Regex::new(r"(?i)insert").unwrap(), + Regex::new(r"(?i)numpad[0-9]").unwrap(), + Regex::new(r"(?i)numpad_multiply").unwrap(), + Regex::new(r"(?i)numpad_add").unwrap(), + Regex::new(r"(?i)numpad_separator").unwrap(), + Regex::new(r"(?i)numpad_subtract").unwrap(), + Regex::new(r"(?i)numpad_decimal").unwrap(), + Regex::new(r"(?i)numpad_divide").unwrap(), + // layout independent versions + Regex::new(r"(?i)\[f[1-9]\]").unwrap(), + Regex::new(r"(?i)\[f1[0-9]\]").unwrap(), + Regex::new(r"(?i)\[Key[A-Z]\]").unwrap(), + Regex::new(r"(?i)\[Digit[0-9]\]").unwrap(), + Regex::new(r"(?i)\[Numpad[0-9]\]").unwrap(), + Regex::new(r"\[Backquote\]").unwrap(), + Regex::new(r"\[Minus\]").unwrap(), + Regex::new(r"\[Equal\]").unwrap(), + Regex::new(r"\[BracketLeft\]").unwrap(), + Regex::new(r"\[BracketRight\]").unwrap(), + Regex::new(r"\[Backslash\]").unwrap(), + Regex::new(r"\[Semicolon\]").unwrap(), + Regex::new(r"\[Quote\]").unwrap(), + Regex::new(r"\[Comma\]").unwrap(), + Regex::new(r"\[Period\]").unwrap(), + Regex::new(r"\[Slash\]").unwrap(), + Regex::new(r"\[ArrowLeft\]").unwrap(), + Regex::new(r"\[ArrowUp\]").unwrap(), + Regex::new(r"\[ArrowRight\]").unwrap(), + Regex::new(r"\[ArrowDown\]").unwrap(), + Regex::new(r"\[PageUp\]").unwrap(), + Regex::new(r"\[PageDown\]").unwrap(), + Regex::new(r"\[End\]").unwrap(), + Regex::new(r"\[Home\]").unwrap(), + Regex::new(r"\[Tab\]").unwrap(), + Regex::new(r"\[Enter\]").unwrap(), + Regex::new(r"\[Escape\]").unwrap(), + Regex::new(r"\[Space\]").unwrap(), + Regex::new(r"\[Backspace\]").unwrap(), + Regex::new(r"\[Delete\]").unwrap(), + Regex::new(r"\[Pause\]").unwrap(), + Regex::new(r"\[CapsLock\]").unwrap(), + Regex::new(r"\[Insert\]").unwrap(), + Regex::new(r"\[NumpadMultiply\]").unwrap(), + Regex::new(r"\[NumpadAdd\]").unwrap(), + Regex::new(r"\[NumpadComma\]").unwrap(), + Regex::new(r"\[NumpadSubtract\]").unwrap(), + Regex::new(r"\[NumpadDecimal\]").unwrap(), + Regex::new(r"\[NumpadDivide\]").unwrap(), + ]; +} + +fn valid_key_binding(val: &Required) -> Result<(), ValidationError> { + match val { + Required::DefaultValue => return Ok(()), + Required::Value(x) => { + if valid_key_binding_str(&x) { + return Err(ValidationError::new("Invalid key binding")); + } else { + return Ok(()); + } + } + }; +} + +fn valid_key_binding_str(str: &str) -> bool { + for press in Regex::new(r"\s+").unwrap().split(str) { + let mut first = true; + for part in press.split('+') { + if first { + first = false; + if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { + return false; + } + } else { + if !MODIFIER_REGEX.is_match(part) { + return false; + } + } + } + } + return false; +} + +/** + * @bindingField bind + * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` + * + * **Example** + * + * ```toml + * [[bind]] + * name = "left" + * key = "h" + * mode = "normal" + * command = "cursorLeft" + * ``` + * The `bind` element has two categories of fields: functional and documenting. + * + * ## Functional Fields + * + * The functional fields determine what the keybinding does. Required fields are marked with + * a `*`. + * + */ +#[derive(Deserialize, Validate)] +pub struct CommandInput { + /** + * @forBindingField bind + * + * - `command`*: A string denoting the command to execute. This is a command + * defined by VSCode or an extension thereof. + * See [finding commands](#finding-commands). This field has special + * behavior for the command `runCommands` + * (see [running multiple commands](#running-multiple-commands)). + */ + #[serde(default)] + command: Required, + + /** + * @forBindingField bind + * + * - `args`: The arguments to directly pass to the `command`, these are static + * values. + */ + #[validate(custom(function = "valid_json_object"))] + #[serde(default)] + args: Option, + + /** + * @forBindingField bind + * + * - `computedArgs`: Like `args` except that each value is a string that is + * evaluated as an [expression](/expressions/index). + */ + // TODO: should be fieldds of strings not a general table (right??) + #[validate(custom(function = "valid_json_object"))] + #[serde(default)] + computedArgs: Option, + + /** + * @forBindingField bind + * + * - `key`*: the + * [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that + * triggers `command`. + */ + #[serde(default)] + #[validate(custom(function = "valid_key_binding"))] + key: Required, + /** + * @forBindingField bind + * + * - `when`: A [when + * clause](https://code.visualstudio.com/api/references/when-clause-contexts) + * context under which the binding will be active. Also see Master Key's + * [available contexts](#available-contexts) + */ + #[serde(default)] + when: Plural, + /** + * @forBindingField bind + * + * - `mode`: The mode during which the binding will be active. The default mode is + * used when this field is not specified (either directly or via the `defaults` + * field). You can also specify multiple modes as an array of strings. To specify + * a binding that is applied in all modes use "{{all_modes}}". + */ + #[serde(default = "default_mode")] + mode: Plural, + /** + * @forBindingField bind + * + * - `priority`: The ordering of the keybinding relative to others; determines which + * bindings take precedence. Defaults to 0. + */ + #[serde(default)] + priority: Option, + /** + * @forBindingField bind + * + * - `defaults`: the hierarchy of defaults applied to this binding, see + * [`default`](/bindings/default) for more details. + */ + #[serde(default)] + defaults: Option, + /** + * @forBindingField bind + * + * - `foreach`: Allows parametric definition of multiple keybindings, see + * [`foreach` clauses](#foreach-clauses). + */ + #[serde(default)] + #[validate(custom(function = "valid_json_array_object"))] + foreach: Option, + + /** + * @forBindingField bind + * + * - `prefixes`: (array of strings or the string + * {{all_prefixes}}). Determines one or more *unresolved* key + * sequences that can have occurred before typing this key. See + * [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. + * no prefix is allowed). This can be set to {{all_prefixes}}, + * if you wish to allow the key binding to work regardless of any unresolved key + * sequence that has been pressed (e.g. this is used for the "escape" key binding + * in Larkin). + */ + #[serde(default)] + prefixes: Plural, + + /** + * @forBindingField bind + * + * - `finalKey`: (boolean, default=true) Whether this key should clear any transient + * state associated with the pending keybinding prefix. See + * [`master-key.prefix`](/commands/prefix) for details. + */ + #[serde(default)] + finalKey: Option, + + /** + * @forBindingField bind + * + * - `computedRepeat`: This is an [expression](/expressions/index). It is expected + * to evaluate to the number of times to repeat the command. Defaults to zero: one + * repeat means the command is run twice. + * - `command` will be repeated the given + * number of times. + */ + computedRepeat: Option, + + /** + * @forBindingField bind + * @order 10 + * + * ## Documenting Fields + * + * The documenting fields determine how the keybinding is documented. They are all + * optional. + * + * - `name`: A very description for the command; this must fit in the visual + * documentation so it shouldn't be much longer than five characters for most + * keys. Favor unicode symbols such as → and ← over text. + */ + #[serde(default)] + name: Option, + + /** + * @forBindingField bind + * @order 10 + * + * - `description`: A longer description of what the command does. Shouldn't be much + * longer than a single sentence for most keys. Save more detailed descriptions + * for the literate comments. + */ + #[serde(default)] + description: Option, + /** + * @forBindingField bind + * @order 10 + * + * - `hideInPalette/hideInDocs`: whether to show the keys in the popup suggestions + * and the documentation. These both default to false. + */ + #[serde(default)] + hideInPalette: Option, + #[serde(default)] + hideInDocs: Option, + + /** + * @forBindingField bind + * @order 10 + * + * - `combinedName/combinedKey/combinedDescription`: in the suggestion palette and + * textual documentation, keys that have the same `combinedName` will be + * represented as single entry, using the `combinedKey` and `combinedDescription` + * instead of `key` and `description`. The `combinedKey` for a multi-key sequence + * should only include the suffix key. All but the first key's `combinedKey` and + * `combinedDescription` are ignored. + */ + #[serde(default)] + combinedName: Option, + #[serde(default)] + combinedKey: Option, + #[serde(default)] + combinedDescription: Option, + + /** + * @forBindingField bind + * @order 10 + * + * - `kind`: The broad cagegory of commands this binding falls under. There should + * be no more than 4-5 of these. Each `kind` here should have a corresponding + * entry in the top-level `kind` array. + */ + #[serde(default)] + kind: Option, + /** + * @forBindingField bind + * @order 5 + * + * - `whenComputed`: an [expression](/expressions/index) that, if evaluated to + * false, the command will not execute. Favor `when` clauses over `whenComputed`. + * The `whenComputed` field is distinct from the `when` clause because it uses the + * scope of expressions rather than when clause statements. Furthermore, even if + * the `whenComputed` is false, the binding is still considered to have triggered, + * and now downstream keybindings will be triggered. It is most useful in + * conjunction with `runCommands` or [`storeCommand`](/commands/storeCommand). + */ + #[serde(default)] + whenComputed: Option, +} + +// TODO: look into std::error::Error trait and `thiserror` +#[derive(Debug)] +pub struct CommandValidationError { + msg: String, +} + +impl From for JsError { + fn from(x: CommandValidationError) -> JsError { + return JsError::new(&format!("`command` validation failed; {}", x.msg)); + } +} + +impl fmt::Display for CommandValidationError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.msg) + } +} + +impl CommandValidationError { + fn new(msg: String) -> CommandValidationError { + return CommandValidationError { msg }; + } +} + +impl From for CommandValidationError { + fn from(e: ValidationError) -> CommandValidationError { + return CommandValidationError::new(format!("Validation error: {}", e)); + } +} + +impl From for CommandValidationError { + fn from(e: toml::de::Error) -> CommandValidationError { + return CommandValidationError::new(format!("Error reading command: {}", e)); + } +} + +impl From for CommandValidationError { + // We don't expect these errors since we have already validated the TOML data + // to serializable to JSON-friendly data + fn from(e: serde_wasm_bindgen::Error) -> CommandValidationError { + return CommandValidationError::new(format!("Unexpected JS conversion error: {}", e)); + } +} + +impl Merging, Option> for Option { + fn merge(self, y: Self) -> Self { + return match self { + Some(_) => self, + None => y, + }; + } + + fn require(self) -> Result { + return Ok(self); + } +} + +// // TODO: before I finish implementing this, make sure I can +// // read in the TOML table values to a javascript +// impl Merging for CommandInput { +// fn merge(self, y: Self) -> Self { +// CommandInput { +// command: self.command.merge(y.command), +// args: self.args.merge(y.args), +// computedArgs: self.computedArgs.merge(y.computedArgs), +// key: self.key.merge(y.key), +// when: self.when.merge(y.when), +// mode: self.mode.merge(y.mode), +// priority: self.priority.merge(y.priority), +// defaults: self.defaults.merge(y.defaults), +// foreach: self.foreach.merge(y.foreach), +// prefixes: self.prefixes.merge(y.prefixes), +// finalKey: self.finalKey.merge(y.finalKey), +// computedRepeat: self.computedRepeat.merge(y.computedRepeat), +// name: self.name.merge(y.name), +// description: self.description.merge(y.description), +// hideInPalette: self.hideInPalette.merge(y.hideInPalette), +// hideInDocs: self.hideInDocs.merge(y.hideInDocs), +// combinedName: self.combinedName.merge(y.combinedName), +// combinedKey: self.combinedKey.merge(y.combinedKey), +// combinedDescription: self.combinedDescription.merge(y.combinedDescription), +// kind: self.kind.merge(y.kind), +// whenComputed: self.whenComputed.merge(y.whenComputed), +// } +// } +// } + +// TODO: do the Table objects get properly understand as basic JS objects +// or do we have to convert them here to JsObjects? +#[wasm_bindgen(getter_with_clone)] +#[allow(non_snake_case)] +pub struct Command { + pub command: String, + pub args: JsValue, + pub computedArgs: JsValue, + pub key: String, + pub when: Vec, + pub mode: Vec, + pub priority: i64, + pub defaults: String, + pub foreach: JsValue, + pub prefixes: Vec, + pub finalKey: bool, + pub computedRepeat: Option, + pub name: Option, + pub description: Option, + pub hideInPalette: Option, + pub hideInDocs: Option, + pub combinedName: Option, + pub combinedKey: Option, + pub combinedDescription: Option, + pub kind: Option, + pub whenComputed: Option, +} + +// TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error + +// TODO: think about whether I want to represent commands as a sequence in the output... +impl Command { + pub fn new(input: CommandInput) -> Result { + return Ok(Command { + command: input.command.require()?, + args: serde_wasm_bindgen::to_value(&input.args.unwrap_or_else(|| toml::Table::new()))?, + computedArgs: serde_wasm_bindgen::to_value( + &input.computedArgs.unwrap_or_else(|| toml::Table::new()), + )?, + key: input.key.require()?, + when: input.when.to_array(), + mode: input.mode.to_array(), + priority: input.priority.unwrap_or(0), + defaults: input.defaults.unwrap_or_default(), + foreach: serde_wasm_bindgen::to_value(&input.foreach.unwrap_or_default())?, + prefixes: input.prefixes.to_array(), + finalKey: input.finalKey.unwrap_or_default(), + computedRepeat: input.computedRepeat, + name: input.name, + description: input.description, + hideInPalette: input.hideInPalette, + hideInDocs: input.hideInDocs, + combinedName: input.combinedName, + combinedKey: input.combinedKey, + combinedDescription: input.combinedDescription, + kind: input.kind, + whenComputed: input.whenComputed, + }); + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn complete_parsing() { + let data = r#" + command = "do" + args = { a = "2", b = 3 } + computedArgs = { c = "1+2" } + key = "a" + when = "joe > 1" + mode = "normal" + priority = 1 + defaults = "foo.bar" + foreach.index = [1,2,3] + prefixes = "c" + finalKey = true + computedRepeat = "2+c" + name = "foo" + description = "foo bar bin" + hideInPalette = false + hideInDocs = false + combinedName = "Up/down" + combinedKey = "A/B" + combinedDescription = "bla bla bla" + kind = "biz" + whenComputed = "f > 2" + "#; + + let result = toml::from_str::(data).unwrap(); + + assert_eq!(result.command, Required::Value("do".into())); + let args = result.args.unwrap(); + assert_eq!(args.get("a").unwrap(), &Value::String("2".into())); + assert_eq!(args.get("b").unwrap(), &Value::Integer(3)); + assert_eq!( + result.computedArgs.unwrap().get("c").unwrap(), + &Value::String("1+2".into()) + ); + assert_eq!(result.key, Required::Value("a".into())); + assert_eq!(result.when, Plural::One("joe > 1".into())); + assert_eq!(result.mode, Plural::One("normal".into())); + assert_eq!(result.priority.unwrap(), 1); + assert_eq!(result.defaults.unwrap(), "foo.bar"); + assert_eq!( + result.foreach.unwrap().get("index").unwrap(), + &Value::Array(vec![1, 2, 3].iter().map(|x| Value::Integer(*x)).collect()) + ); + assert_eq!(result.prefixes, Plural::One("c".into())); + assert_eq!(result.finalKey.unwrap(), true); + assert_eq!(result.name.unwrap(), "foo"); + assert_eq!(result.description.unwrap(), "foo bar bin"); + assert_eq!(result.hideInDocs.unwrap(), false); + assert_eq!(result.hideInPalette.unwrap(), false); + assert_eq!(result.combinedName.unwrap(), "Up/down"); + assert_eq!(result.combinedKey.unwrap(), "A/B"); + assert_eq!(result.combinedDescription.unwrap(), "bla bla bla"); + assert_eq!(result.kind.unwrap(), "biz"); + assert_eq!(result.whenComputed.unwrap(), "f > 2"); + } + + // TODO: can handle defaults + // TODO: errors on missing required fields + // TODO: doesn't error on missing non-required fields + // +} + +// TODO: define the "output" type for `Command` that can actually be passed to javascript diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs new file mode 100644 index 00000000..314e01d4 --- /dev/null +++ b/src/rust/parsing/src/lib.rs @@ -0,0 +1,8 @@ +pub mod command; + +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +pub fn simple() -> String { + return "hello from rust!".into(); +} diff --git a/tsconfig.json b/tsconfig.json index b52da576..2f21df49 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -22,9 +22,9 @@ ], "exclude": [ "src/test/**/*.ts", - "src/oldtest/**/*.mts", "out/**/*.js", "src/oldtest/**", + "src/oldparsing/**", "src/rust/parsing/lib/**/*.{js,d.ts}", ] } From 7544022bc84731903bcf7415166d36ae1c6720f7 Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 13 Jul 2025 08:21:55 -0400 Subject: [PATCH 02/79] implementing `merge` Created using spr 1.3.6-beta.1 --- src/extension/keybindings/index.ts | 6 +- src/rust/parsing/Cargo.lock | 21 +++ src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/src/command.rs | 268 ++++++++++++++--------------- src/rust/parsing/src/error.rs | 17 ++ src/rust/parsing/src/lib.rs | 1 + 6 files changed, 172 insertions(+), 142 deletions(-) create mode 100644 src/rust/parsing/src/error.rs diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index b04fa483..91d296b5 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -679,14 +679,14 @@ export async function activate(context: vscode.ExtensionContext) { vscode.window.showInformationMessage(`Rust says: command: ${parsing.command} - args: ${parsing.args} - computedArgs: ${parsing.computedArgs} + args: ${JSON.stringify(parsing.args, null, 2)} + computedArgs: ${JSON.stringify(parsing.computedArgs, null, 2)} key: ${parsing.key} when: ${parsing.when} mode: ${parsing.mode} priority: ${parsing.priority} defaults: ${parsing.defaults} - foreach: ${parsing.foreach} + foreach: ${JSON.stringify(parsing.foreach, null, 2)} prefixes: ${parsing.prefixes} finalKey: ${parsing.finalKey} computedRepeat: ${parsing.computedRepeat} diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 2d6528d7..7bd4ac17 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -273,6 +273,7 @@ dependencies = [ "regex", "serde", "serde-wasm-bindgen", + "thiserror", "toml", "validator", "wasm-bindgen", @@ -466,6 +467,26 @@ dependencies = [ "syn", ] +[[package]] +name = "thiserror" +version = "2.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "tinystr" version = "0.8.1" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 737aada9..2049c27b 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -8,6 +8,7 @@ lazy_static = "1.5.0" regex = "1.11.1" serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" +thiserror = "2.0.12" toml = "0.8.23" validator = { version = "0.20.0", features = ["derive"] } wasm-bindgen = "0.2.100" diff --git a/src/rust/parsing/src/command.rs b/src/rust/parsing/src/command.rs index a9606193..bc27439c 100644 --- a/src/rust/parsing/src/command.rs +++ b/src/rust/parsing/src/command.rs @@ -1,93 +1,58 @@ #![allow(non_snake_case)] -use core::fmt; +use crate::error::{Error, Result}; + use lazy_static::lazy_static; use regex::Regex; -use serde::{Deserialize, Deserializer, Serialize}; +use serde::de::Unexpected; +use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; -use std::collections::HashMap; use toml::Value; -use toml::map::Map; use validator::{Validate, ValidationError}; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; #[wasm_bindgen] -pub fn debug_parse_command(command_str: &str) -> Result { +pub fn debug_parse_command(command_str: &str) -> std::result::Result { let result = toml::from_str::(command_str)?; - return match Command::new(result) { - Ok(x) => Ok(x), - Err(e) => Err(JsError::from(e)), - }; + return Ok(Command::new(result)?); } // ---------------------------------- // Validate TOML table structure -trait FoundError { - fn found_error(self) -> Result<(), T>; -} - -impl FoundError for Option { - fn found_error(self) -> Result<(), T> { - return match self { - Some(err) => Err(err), - None => Ok(()), - }; - } -} - -fn valid_json_array(values: &Vec) -> Result<(), ValidationError> { - return values - .iter() - .find_map(|x| match valid_json_value(x) { - Ok(()) => None, - Err(err) => Some(err), - }) - .found_error(); +fn valid_json_array(values: &Vec) -> std::result::Result<(), ValidationError> { + return values.iter().try_for_each(valid_json_value); } -fn valid_json_object(kv: &toml::Table) -> Result<(), ValidationError> { - return kv - .iter() - .find_map(|(_, v)| match valid_json_value(v) { - Ok(()) => None, - Err(err) => Some(err), - }) - .found_error(); +fn valid_json_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { + return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); } // we read in TOML values, but only want to accept JSON-valid values in some contexts // (since that is what we'll be serializing out to) -fn valid_json_value(x: &Value) -> Result<(), ValidationError> { +fn valid_json_value(x: &Value) -> std::result::Result<(), ValidationError> { match x { Value::Integer(_) | Value::Float(_) | Value::Boolean(_) | Value::String(_) => { return Ok(()); } - Value::Datetime(_) => return Err(ValidationError::new("Unexpected datetime value")), + Value::Datetime(_) => { + return Err(ValidationError::new("DateTime values are not supported")); + } Value::Array(values) => return valid_json_array(values), Value::Table(kv) => return valid_json_object(kv), }; } -fn valid_json_array_object(kv: &toml::Table) -> Result<(), ValidationError> { - return kv - .iter() - .find_map(|(_, v)| match v { - Value::Array(_) => match valid_json_value(v) { - Ok(()) => None, - Err(err) => Some(err), - }, - _ => Some(ValidationError::new( - "Expected all object fields to be arrays", - )), - }) - .found_error(); +fn valid_json_array_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { + return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); } -trait Merging { - fn merge(self, default: T) -> T; - fn require(self) -> Result; +trait Merging { + fn merge(self, new: Self) -> Self; +} +trait Requiring { + fn require(self, name: &'static str) -> Result; } #[derive(Default, Deserialize, PartialEq, Debug)] @@ -99,6 +64,15 @@ enum Plural { Many(Vec), } +impl Merging for Plural { + fn merge(self, new: Self) -> Self { + return match new { + Plural::Zero => self, + _ => new, + }; + } +} + impl Plural { fn to_array(self) -> Vec { return match self { @@ -119,20 +93,24 @@ enum Required { Value(T), } -impl Merging, T> for Required { - fn require(self) -> Result { +impl Requiring for Required { + fn require(self, name: &'static str) -> Result { return match self { - Required::DefaultValue => { - Err(CommandValidationError::new("Missing required field".into())) - } + Required::DefaultValue => Err(Error::RequiredField(name)), Required::Value(val) => Ok(val), }; } - fn merge(self, default: Self) -> Self { - match self { - Required::Value(_) => self, - Required::DefaultValue => default, - } +} + +impl Merging for Required { + fn merge(self, new: Self) -> Self { + return match new { + Required::Value(new_val) => match self { + Required::Value(old_val) => Required::Value(old_val.merge(new_val)), + Required::DefaultValue => Required::Value(new_val), + }, + Required::DefaultValue => self, + }; } } @@ -225,7 +203,7 @@ lazy_static! { ]; } -fn valid_key_binding(val: &Required) -> Result<(), ValidationError> { +fn valid_key_binding(val: &Required) -> std::result::Result<(), ValidationError> { match val { Required::DefaultValue => return Ok(()), Required::Value(x) => { @@ -487,93 +465,99 @@ pub struct CommandInput { whenComputed: Option, } -// TODO: look into std::error::Error trait and `thiserror` -#[derive(Debug)] -pub struct CommandValidationError { - msg: String, +impl Merging for Option { + fn merge(self, new: Self) -> Self { + return match new { + Some(x) => match self { + Some(y) => Some(y.merge(x)), + None => Some(x), + }, + None => self, + }; + } } -impl From for JsError { - fn from(x: CommandValidationError) -> JsError { - return JsError::new(&format!("`command` validation failed; {}", x.msg)); +impl Merging for String { + fn merge(self, _: Self) -> Self { + return self; } } -impl fmt::Display for CommandValidationError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}", self.msg) +impl Merging for i64 { + fn merge(self, _: Self) -> Self { + return self; } } -impl CommandValidationError { - fn new(msg: String) -> CommandValidationError { - return CommandValidationError { msg }; +impl Merging for bool { + fn merge(self, _: Self) -> Self { + return self; } } -impl From for CommandValidationError { - fn from(e: ValidationError) -> CommandValidationError { - return CommandValidationError::new(format!("Validation error: {}", e)); +impl Merging for toml::Value { + fn merge(self, new: Self) -> Self { + match new { + Value::Array(mut new_values) => match self { + Value::Array(mut old_values) => { + old_values.append(&mut new_values); + Value::Array(old_values) + } + _ => Value::Array(new_values), + }, + Value::Table(new_kv) => match self { + Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), + _ => Value::Table(new_kv), + }, + _ => new, + } } } -impl From for CommandValidationError { - fn from(e: toml::de::Error) -> CommandValidationError { - return CommandValidationError::new(format!("Error reading command: {}", e)); +// TODO: think through ownship here +impl Merging for toml::Table { + fn merge(mut self, new: Self) -> Self { + self.extend(new); + return self; } } -impl From for CommandValidationError { - // We don't expect these errors since we have already validated the TOML data - // to serializable to JSON-friendly data - fn from(e: serde_wasm_bindgen::Error) -> CommandValidationError { - return CommandValidationError::new(format!("Unexpected JS conversion error: {}", e)); +impl Requiring> for Option { + fn require(self, _: &str) -> Result { + return Ok(self); } } -impl Merging, Option> for Option { +// TODO: before I finish implementing this, make sure I can +// read in the TOML table values to a javascript +impl Merging for CommandInput { fn merge(self, y: Self) -> Self { - return match self { - Some(_) => self, - None => y, - }; - } - - fn require(self) -> Result { - return Ok(self); + CommandInput { + command: self.command.merge(y.command), + args: self.args.merge(y.args), + computedArgs: self.computedArgs.merge(y.computedArgs), + key: self.key.merge(y.key), + when: self.when.merge(y.when), + mode: self.mode.merge(y.mode), + priority: self.priority.merge(y.priority), + defaults: self.defaults.merge(y.defaults), + foreach: self.foreach.merge(y.foreach), + prefixes: self.prefixes.merge(y.prefixes), + finalKey: self.finalKey.merge(y.finalKey), + computedRepeat: self.computedRepeat.merge(y.computedRepeat), + name: self.name.merge(y.name), + description: self.description.merge(y.description), + hideInPalette: self.hideInPalette.merge(y.hideInPalette), + hideInDocs: self.hideInDocs.merge(y.hideInDocs), + combinedName: self.combinedName.merge(y.combinedName), + combinedKey: self.combinedKey.merge(y.combinedKey), + combinedDescription: self.combinedDescription.merge(y.combinedDescription), + kind: self.kind.merge(y.kind), + whenComputed: self.whenComputed.merge(y.whenComputed), + } } } -// // TODO: before I finish implementing this, make sure I can -// // read in the TOML table values to a javascript -// impl Merging for CommandInput { -// fn merge(self, y: Self) -> Self { -// CommandInput { -// command: self.command.merge(y.command), -// args: self.args.merge(y.args), -// computedArgs: self.computedArgs.merge(y.computedArgs), -// key: self.key.merge(y.key), -// when: self.when.merge(y.when), -// mode: self.mode.merge(y.mode), -// priority: self.priority.merge(y.priority), -// defaults: self.defaults.merge(y.defaults), -// foreach: self.foreach.merge(y.foreach), -// prefixes: self.prefixes.merge(y.prefixes), -// finalKey: self.finalKey.merge(y.finalKey), -// computedRepeat: self.computedRepeat.merge(y.computedRepeat), -// name: self.name.merge(y.name), -// description: self.description.merge(y.description), -// hideInPalette: self.hideInPalette.merge(y.hideInPalette), -// hideInDocs: self.hideInDocs.merge(y.hideInDocs), -// combinedName: self.combinedName.merge(y.combinedName), -// combinedKey: self.combinedKey.merge(y.combinedKey), -// combinedDescription: self.combinedDescription.merge(y.combinedDescription), -// kind: self.kind.merge(y.kind), -// whenComputed: self.whenComputed.merge(y.whenComputed), -// } -// } -// } - // TODO: do the Table objects get properly understand as basic JS objects // or do we have to convert them here to JsObjects? #[wasm_bindgen(getter_with_clone)] @@ -587,7 +571,6 @@ pub struct Command { pub mode: Vec, pub priority: i64, pub defaults: String, - pub foreach: JsValue, pub prefixes: Vec, pub finalKey: bool, pub computedRepeat: Option, @@ -606,19 +589,26 @@ pub struct Command { // TODO: think about whether I want to represent commands as a sequence in the output... impl Command { - pub fn new(input: CommandInput) -> Result { + pub fn new(input: CommandInput) -> Result { + if let Some(_) = input.foreach { + return Err(Error::Unexpected("`foreach` remains unresolved")); + } + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return Ok(Command { - command: input.command.require()?, - args: serde_wasm_bindgen::to_value(&input.args.unwrap_or_else(|| toml::Table::new()))?, - computedArgs: serde_wasm_bindgen::to_value( - &input.computedArgs.unwrap_or_else(|| toml::Table::new()), - )?, - key: input.key.require()?, + command: input.command.require("command")?, + args: input + .args + .unwrap_or_else(|| toml::Table::new()) + .serialize(&to_json)?, + computedArgs: input + .computedArgs + .unwrap_or_else(|| toml::Table::new()) + .serialize(&to_json)?, + key: input.key.require("key")?, when: input.when.to_array(), mode: input.mode.to_array(), priority: input.priority.unwrap_or(0), defaults: input.defaults.unwrap_or_default(), - foreach: serde_wasm_bindgen::to_value(&input.foreach.unwrap_or_default())?, prefixes: input.prefixes.to_array(), finalKey: input.finalKey.unwrap_or_default(), computedRepeat: input.computedRepeat, diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs new file mode 100644 index 00000000..c53054ec --- /dev/null +++ b/src/rust/parsing/src/error.rs @@ -0,0 +1,17 @@ +use thiserror::Error; + +#[derive(Debug, Error)] +pub enum Error { + #[error("Parsing Error: {0}")] + Parsing(#[from] toml::de::Error), + #[error("Validation Error: {0}")] + Validation(#[from] validator::ValidationError), + #[error("Unexpected error binding rust values to javascript: {0}")] + JavaScriptError(#[from] serde_wasm_bindgen::Error), + #[error("Missing required field `{0}`")] + RequiredField(&'static str), + #[error("Unexpected error: {0}")] + Unexpected(&'static str), +} + +pub type Result = std::result::Result; diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 314e01d4..2b32da55 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,4 +1,5 @@ pub mod command; +mod error; use wasm_bindgen::prelude::*; From 9e4187858f7892c36cc570dc91ae007984e470d2 Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 14 Jul 2025 22:46:32 -0400 Subject: [PATCH 03/79] wip command `foreach` and `merge` Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/command.rs | 246 +++++++++++++++++++++++++------- 1 file changed, 197 insertions(+), 49 deletions(-) diff --git a/src/rust/parsing/src/command.rs b/src/rust/parsing/src/command.rs index bc27439c..96b3fba1 100644 --- a/src/rust/parsing/src/command.rs +++ b/src/rust/parsing/src/command.rs @@ -4,7 +4,6 @@ use crate::error::{Error, Result}; use lazy_static::lazy_static; use regex::Regex; -use serde::de::Unexpected; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; use toml::Value; @@ -55,7 +54,7 @@ trait Requiring { fn require(self, name: &'static str) -> Result; } -#[derive(Default, Deserialize, PartialEq, Debug)] +#[derive(Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged)] enum Plural { #[default] @@ -64,12 +63,18 @@ enum Plural { Many(Vec), } -impl Merging for Plural { - fn merge(self, new: Self) -> Self { - return match new { - Plural::Zero => self, - _ => new, - }; +impl ForeachExpanding for Plural { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + match self { + Plural::Zero => Plural::Zero, + Plural::One(x) => Plural::One(x.expand_foreach_value(var, value)), + Plural::Many(items) => Plural::Many( + items + .iter() + .map(|v| v.expand_foreach_value(var, value)) + .collect(), + ), + } } } @@ -83,9 +88,18 @@ impl Plural { } } +impl Plural { + fn or(self, default: Plural) -> Plural { + return match self { + Plural::Zero => default, + _ => self, + }; + } +} + // required values are only required at the very end of parsing, once all known defaults // have been resolved -#[derive(Default, Deserialize, Serialize, PartialEq, Debug)] +#[derive(Default, Deserialize, Serialize, PartialEq, Debug, Clone)] #[serde(untagged)] enum Required { #[default] @@ -93,6 +107,8 @@ enum Required { Value(T), } +impl Required {} + impl Requiring for Required { fn require(self, name: &'static str) -> Result { return match self { @@ -102,18 +118,66 @@ impl Requiring for Required { } } -impl Merging for Required { - fn merge(self, new: Self) -> Self { +impl Required { + fn or(self, new: Self) -> Self { return match new { Required::Value(new_val) => match self { - Required::Value(old_val) => Required::Value(old_val.merge(new_val)), Required::DefaultValue => Required::Value(new_val), + _ => self, }, Required::DefaultValue => self, }; } } +impl ForeachExpanding for Required { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return match self { + Required::DefaultValue => Required::DefaultValue, + Required::Value(x) => Required::Value(x.expand_foreach_value(var, value)), + }; + } +} + +impl ForeachExpanding for toml::map::Map { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + let mut result = toml::map::Map::new(); + for (k, v) in self { + result[k] = v.expand_foreach_value(var, value); + } + return result; + } +} + +impl ForeachExpanding for toml::Value { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + match self { + Value::String(str) => Value::String(str.expand_foreach_value(var, value)), + Value::Array(items) => Value::Array( + items + .iter() + .map(|i| i.expand_foreach_value(var, value)) + .collect(), + ), + Value::Table(kv) => Value::Table(kv.expand_foreach_value(var, value)), + other => other.clone(), + } + } +} + +impl ForeachExpanding for Option { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return match self { + Some(v) => Some(v.expand_foreach_value(var, value)), + None => None, + }; + } +} + +trait ForeachExpanding { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self; +} + fn default_mode() -> Plural { return Plural::One("default".into()); } @@ -256,7 +320,7 @@ fn valid_key_binding_str(str: &str) -> bool { * a `*`. * */ -#[derive(Deserialize, Validate)] +#[derive(Deserialize, Validate, Clone)] pub struct CommandInput { /** * @forBindingField bind @@ -483,25 +547,36 @@ impl Merging for String { } } -impl Merging for i64 { - fn merge(self, _: Self) -> Self { - return self; - } -} - -impl Merging for bool { - fn merge(self, _: Self) -> Self { - return self; +impl ForeachExpanding for String { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return self.replace(&format!("{}{var}{}", "{{", "}}"), value); } } impl Merging for toml::Value { fn merge(self, new: Self) -> Self { match new { - Value::Array(mut new_values) => match self { - Value::Array(mut old_values) => { - old_values.append(&mut new_values); - Value::Array(old_values) + Value::Array(new_values) => match self { + Value::Array(old_values) => { + let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); + let mut new_iter = new_values.iter(); + let mut old_iter = old_values.iter(); + loop { + let new_item = new_iter.next(); + let old_item = old_iter.next(); + if let Some(new_val) = new_item { + if let Some(old_val) = old_item { + result.push(old_val.clone().merge(new_val.clone())); + } else { + result.push(new_val.clone()); + } + } else if let Some(old_val) = old_item { + result.push(old_val.clone()); + } else { + break; + } + } + Value::Array(result) } _ => Value::Array(new_values), }, @@ -528,38 +603,34 @@ impl Requiring> for Option { } } -// TODO: before I finish implementing this, make sure I can -// read in the TOML table values to a javascript impl Merging for CommandInput { fn merge(self, y: Self) -> Self { CommandInput { - command: self.command.merge(y.command), + command: y.command.or(self.command), args: self.args.merge(y.args), computedArgs: self.computedArgs.merge(y.computedArgs), - key: self.key.merge(y.key), - when: self.when.merge(y.when), - mode: self.mode.merge(y.mode), - priority: self.priority.merge(y.priority), - defaults: self.defaults.merge(y.defaults), - foreach: self.foreach.merge(y.foreach), - prefixes: self.prefixes.merge(y.prefixes), - finalKey: self.finalKey.merge(y.finalKey), - computedRepeat: self.computedRepeat.merge(y.computedRepeat), - name: self.name.merge(y.name), - description: self.description.merge(y.description), - hideInPalette: self.hideInPalette.merge(y.hideInPalette), - hideInDocs: self.hideInDocs.merge(y.hideInDocs), - combinedName: self.combinedName.merge(y.combinedName), - combinedKey: self.combinedKey.merge(y.combinedKey), - combinedDescription: self.combinedDescription.merge(y.combinedDescription), - kind: self.kind.merge(y.kind), - whenComputed: self.whenComputed.merge(y.whenComputed), + key: y.key.or(self.key), + when: y.when.or(self.when), + mode: y.mode.or(self.mode), + priority: y.priority.or(self.priority), + defaults: y.defaults.or(self.defaults), + foreach: self.foreach, + prefixes: y.prefixes.or(self.prefixes), + finalKey: y.finalKey.or(self.finalKey), + computedRepeat: y.computedRepeat.or(self.computedRepeat), + name: y.name.or(self.name), + description: y.description.or(self.description), + hideInPalette: y.hideInPalette.or(self.hideInPalette), + hideInDocs: y.hideInDocs.or(self.hideInDocs), + combinedName: y.combinedName.or(self.combinedName), + combinedKey: y.combinedKey.or(self.combinedKey), + combinedDescription: y.combinedDescription.or(self.combinedDescription), + kind: y.kind.or(self.kind), + whenComputed: y.whenComputed.or(self.whenComputed), } } } -// TODO: do the Table objects get properly understand as basic JS objects -// or do we have to convert them here to JsObjects? #[wasm_bindgen(getter_with_clone)] #[allow(non_snake_case)] pub struct Command { @@ -587,6 +658,81 @@ pub struct Command { // TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error +impl CommandInput { + fn has_foreach(&self) -> bool { + if let Some(foreach) = &self.foreach { + return foreach.len() > 0; + } + return false; + } + + fn expand_foreach(&mut self) -> Result> { + let mut result = vec![]; + while self.has_foreach() { + result = self.expand_foreach_once(&result)?; + } + return Ok(result); + } + + fn expand_foreach_once(&mut self, inputs: &Vec) -> Result> { + let foreach = match &self.foreach { + Some(foreach) => foreach, + None => &toml::map::Map::new(), + }; + let mut final_foreach = foreach.clone(); + let mut iter = foreach.iter(); + let first = iter.next(); + if let Some(item) = first { + let (var, values) = item; + final_foreach.remove(var); + + if let Value::Array(items) = values { + let mut result = Vec::with_capacity(inputs.len() * items.len()); + for input in inputs { + for value in items { + let str = format!("{}", value); + result.push(input.expand_foreach_value(var, &str)); + } + } + self.foreach = Some(final_foreach); + return Ok(result); + } else { + return Err(Error::Unexpected( + "`foreach` was expected to be a key of arrays.`", + )); + } + } else { + return Ok(vec![]); + } + } + + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return CommandInput { + command: self.command.expand_foreach_value(var, value), + args: self.args.expand_foreach_value(var, value), + computedArgs: self.computedArgs.expand_foreach_value(var, value), + key: self.key.expand_foreach_value(var, value), + when: self.when.expand_foreach_value(var, value), + mode: self.mode.expand_foreach_value(var, value), + priority: self.priority, + defaults: self.defaults.expand_foreach_value(var, value), + prefixes: self.prefixes.expand_foreach_value(var, value), + finalKey: self.finalKey, + computedRepeat: self.computedRepeat.expand_foreach_value(var, value), + foreach: None, + name: self.name.expand_foreach_value(var, value), + description: self.description.expand_foreach_value(var, value), + hideInPalette: self.hideInPalette, + hideInDocs: self.hideInDocs, + combinedName: self.combinedName.expand_foreach_value(var, value), + combinedKey: self.combinedKey.expand_foreach_value(var, value), + combinedDescription: self.combinedDescription.expand_foreach_value(var, value), + kind: self.kind.expand_foreach_value(var, value), + whenComputed: self.whenComputed.expand_foreach_value(var, value), + }; + } +} + // TODO: think about whether I want to represent commands as a sequence in the output... impl Command { pub fn new(input: CommandInput) -> Result { @@ -687,7 +833,9 @@ mod tests { } // TODO: can handle defaults + // TODO: can merge from defaults // TODO: errors on missing required fields + // TODO: can expand foreach // TODO: doesn't error on missing non-required fields // } From 27ef0b9aee8d498bb7f23243792e38bfc158b0c0 Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 14 Jul 2025 23:30:04 -0400 Subject: [PATCH 04/79] working default tests, rust refactor roadmap Created using spr 1.3.6-beta.1 --- mise.toml | 4 ++ notes.md | 27 ++++++++++++- src/rust/parsing/src/command.rs | 70 +++++++++++++++++++++++++++++++-- 3 files changed, 96 insertions(+), 5 deletions(-) diff --git a/mise.toml b/mise.toml index a9117c54..5da6480f 100644 --- a/mise.toml +++ b/mise.toml @@ -28,6 +28,10 @@ run = [ 'cp lib/parsing_bg.wasm ../../../out/parsing_bg.wasm', ] +[tasks.test-rust] +dir = 'src/rust/parsing' +run = 'cargo test' + [tasks.build] depends = ['check-types', 'lint', 'build-rust'] sources = ['src/**/*.ts'] diff --git a/notes.md b/notes.md index 3796742f..3fcc84dd 100644 --- a/notes.md +++ b/notes.md @@ -67,7 +67,32 @@ Integration test debugging: 3. Refactor parsing to rust a. in this early phase, we don't worry too much about providing detailed error messages (if there are easy things to do here we can do them, but no UX work, etc...) - - [ ] start by implementing parsing of `[[bind]]` + - [ ] start by implementing parsing of `[[bind]]` + - [x] basic parsing + - [~] merging defaults (unit tests remain) + - [~] foreach expansion (unit tests remain) + - [ ] refactor code + - [ ] validation that `master-key.prefix` uses `finalKey` + - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region + - [ ] validate by checking error reporting + NOTE: short term goal here is to support literate docs + - [ ] pipeline for `[[bind]]` entries + - [ ] basic pipeline + - [ ] proper parsing with `[[default]]` and `defaults` + - [ ] mode expansion + - [ ] documentation expandsion/validation across all `[[bind]]` values + with the same key and mode + - [ ] key-sequence expansion and duplicate resolution + - [ ] proper parsing and expansion of `[[define]]` sections + - [ ] proper conversion to keybindings.json command + - [ ] expand prefixes to prefixCode and move to when clause + - [ ] move mode to when clause + - [ ] extraction of markdown docs + - [ ] extract all comment regions (exclude `#-`) + - [ ] replace `[[bind]]` regions: + - [ ] identify each non-comment region, and look for parsed elements + whose span overlaps + - [ ] convert any bind elements in this overlap into markdown table 4. Move palette from quick pick to tree view - [ ] get a simple tree view working (just show one item) - [ ] get tree view to show palette items diff --git a/src/rust/parsing/src/command.rs b/src/rust/parsing/src/command.rs index 96b3fba1..3005aa07 100644 --- a/src/rust/parsing/src/command.rs +++ b/src/rust/parsing/src/command.rs @@ -118,6 +118,15 @@ impl Requiring for Required { } } +impl Required { + fn unwrap(self) -> T { + return match self { + Required::Value(x) => x, + Required::DefaultValue => panic!("Required value missing"), + }; + } +} + impl Required { fn or(self, new: Self) -> Self { return match new { @@ -773,6 +782,8 @@ impl Command { #[cfg(test)] mod tests { + use std::collections::HashMap; + use super::*; #[test] fn complete_parsing() { @@ -832,12 +843,63 @@ mod tests { assert_eq!(result.whenComputed.unwrap(), "f > 2"); } - // TODO: can handle defaults - // TODO: can merge from defaults + #[test] + fn default_parsing() { + let data = r#" + key = "l" + command = "cursorMove" + args.to = "left" + "#; + + let result = toml::from_str::(data).unwrap(); + assert_eq!(result.key.unwrap(), "l"); + assert_eq!(result.command.unwrap(), "cursorMove"); + assert_eq!( + result.args.unwrap().get("to").unwrap().as_str().unwrap(), + "left" + ); + + assert_eq!(result.when, Plural::Zero); + assert_eq!(result.combinedDescription, None); + assert_eq!(result.combinedName, None); + } + + #[test] + fn simple_command_merging() { + let data = r#" + [[bind]] + name = "default" + command = "cursorMove" + computedArgs.value = "count" + + [[bind]] + key = "l" + name = "←" + args.to = "left" + "#; + + let result = toml::from_str::>>(data).unwrap(); + let default = result.get("bind").unwrap()[0].clone(); + let left = result.get("bind").unwrap()[1].clone(); + let left = default.merge(left); + assert_eq!(left.key.unwrap(), "l"); + assert_eq!(left.command.unwrap(), "cursorMove"); + assert_eq!( + left.args.unwrap().get("to").unwrap().as_str().unwrap(), + "left" + ); + + assert_eq!(left.when, Plural::Zero); + assert_eq!(left.combinedDescription, None); + assert_eq!(left.combinedName, None); + } + + // TODO: test more elaborate merging scenarios + // (e.g. nested argument structures, proper overlaoding of lists + // of when clauses, array of arguments that get properly merged) + // TODO: errors on missing required fields // TODO: can expand foreach - // TODO: doesn't error on missing non-required fields - // } // TODO: define the "output" type for `Command` that can actually be passed to javascript From 5cde003743cae0c9bae29f1bdf46827dd7db8cee Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 15 Jul 2025 10:22:14 -0400 Subject: [PATCH 05/79] refactor command code Created using spr 1.3.6-beta.1 --- notes.md | 7 + src/rust/parsing/src/command/foreach.rs | 65 ++++ .../src/{command.rs => command/mod.rs} | 363 +----------------- src/rust/parsing/src/command/validation.rs | 149 +++++++ src/rust/parsing/src/lib.rs | 1 + src/rust/parsing/src/util.rs | 145 +++++++ 6 files changed, 374 insertions(+), 356 deletions(-) create mode 100644 src/rust/parsing/src/command/foreach.rs rename src/rust/parsing/src/{command.rs => command/mod.rs} (62%) create mode 100644 src/rust/parsing/src/command/validation.rs create mode 100644 src/rust/parsing/src/util.rs diff --git a/notes.md b/notes.md index 3fcc84dd..e3910c67 100644 --- a/notes.md +++ b/notes.md @@ -93,6 +93,13 @@ Integration test debugging: - [ ] identify each non-comment region, and look for parsed elements whose span overlaps - [ ] convert any bind elements in this overlap into markdown table + - [ ] actually replace javascript behavior with rust functions + - [ ] CI + - [ ] setup CI unit tests for rust + - [ ] setup rust coverage + - [ ] setup CI and merge coverage across rust and javascript + - [ ] maybe: https://github.com/mweibel/lcov-result-merger (research others) + 4. Move palette from quick pick to tree view - [ ] get a simple tree view working (just show one item) - [ ] get tree view to show palette items diff --git a/src/rust/parsing/src/command/foreach.rs b/src/rust/parsing/src/command/foreach.rs new file mode 100644 index 00000000..55bd876e --- /dev/null +++ b/src/rust/parsing/src/command/foreach.rs @@ -0,0 +1,65 @@ +use crate::util::{Plural, Required}; +use toml::Value; + +pub trait ForeachExpanding { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self; +} + +impl ForeachExpanding for Plural { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + match self { + Plural::Zero => Plural::Zero, + Plural::One(x) => Plural::One(x.expand_foreach_value(var, value)), + Plural::Many(items) => Plural::Many( + items + .iter() + .map(|v| v.expand_foreach_value(var, value)) + .collect(), + ), + } + } +} + +impl ForeachExpanding for Required { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return match self { + Required::DefaultValue => Required::DefaultValue, + Required::Value(x) => Required::Value(x.expand_foreach_value(var, value)), + }; + } +} + +impl ForeachExpanding for toml::map::Map { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + let mut result = toml::map::Map::new(); + for (k, v) in self { + result[k] = v.expand_foreach_value(var, value); + } + return result; + } +} + +impl ForeachExpanding for toml::Value { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + match self { + Value::String(str) => Value::String(str.expand_foreach_value(var, value)), + Value::Array(items) => Value::Array( + items + .iter() + .map(|i| i.expand_foreach_value(var, value)) + .collect(), + ), + Value::Table(kv) => Value::Table(kv.expand_foreach_value(var, value)), + other => other.clone(), + } + } +} + +impl ForeachExpanding for Option { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return match self { + Some(v) => Some(v.expand_foreach_value(var, value)), + None => None, + }; + } +} diff --git a/src/rust/parsing/src/command.rs b/src/rust/parsing/src/command/mod.rs similarity index 62% rename from src/rust/parsing/src/command.rs rename to src/rust/parsing/src/command/mod.rs index 3005aa07..329c9a9a 100644 --- a/src/rust/parsing/src/command.rs +++ b/src/rust/parsing/src/command/mod.rs @@ -1,13 +1,17 @@ #![allow(non_snake_case)] +mod foreach; +mod validation; + use crate::error::{Error, Result}; +use crate::util::{Merging, Plural, Required, Requiring}; +use foreach::ForeachExpanding; +use validation::{valid_json_array_object, valid_json_object, valid_key_binding}; -use lazy_static::lazy_static; -use regex::Regex; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; use toml::Value; -use validator::{Validate, ValidationError}; +use validator::Validate; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; @@ -19,295 +23,10 @@ pub fn debug_parse_command(command_str: &str) -> std::result::Result) -> std::result::Result<(), ValidationError> { - return values.iter().try_for_each(valid_json_value); -} - -fn valid_json_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { - return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); -} - -// we read in TOML values, but only want to accept JSON-valid values in some contexts -// (since that is what we'll be serializing out to) -fn valid_json_value(x: &Value) -> std::result::Result<(), ValidationError> { - match x { - Value::Integer(_) | Value::Float(_) | Value::Boolean(_) | Value::String(_) => { - return Ok(()); - } - Value::Datetime(_) => { - return Err(ValidationError::new("DateTime values are not supported")); - } - Value::Array(values) => return valid_json_array(values), - Value::Table(kv) => return valid_json_object(kv), - }; -} - -fn valid_json_array_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { - return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); -} - -trait Merging { - fn merge(self, new: Self) -> Self; -} -trait Requiring { - fn require(self, name: &'static str) -> Result; -} - -#[derive(Default, Deserialize, PartialEq, Debug, Clone)] -#[serde(untagged)] -enum Plural { - #[default] - Zero, - One(T), - Many(Vec), -} - -impl ForeachExpanding for Plural { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - match self { - Plural::Zero => Plural::Zero, - Plural::One(x) => Plural::One(x.expand_foreach_value(var, value)), - Plural::Many(items) => Plural::Many( - items - .iter() - .map(|v| v.expand_foreach_value(var, value)) - .collect(), - ), - } - } -} - -impl Plural { - fn to_array(self) -> Vec { - return match self { - Plural::Zero => Vec::new(), - Plural::One(val) => vec![val], - Plural::Many(vals) => vals, - }; - } -} - -impl Plural { - fn or(self, default: Plural) -> Plural { - return match self { - Plural::Zero => default, - _ => self, - }; - } -} - -// required values are only required at the very end of parsing, once all known defaults -// have been resolved -#[derive(Default, Deserialize, Serialize, PartialEq, Debug, Clone)] -#[serde(untagged)] -enum Required { - #[default] - DefaultValue, - Value(T), -} - -impl Required {} - -impl Requiring for Required { - fn require(self, name: &'static str) -> Result { - return match self { - Required::DefaultValue => Err(Error::RequiredField(name)), - Required::Value(val) => Ok(val), - }; - } -} - -impl Required { - fn unwrap(self) -> T { - return match self { - Required::Value(x) => x, - Required::DefaultValue => panic!("Required value missing"), - }; - } -} - -impl Required { - fn or(self, new: Self) -> Self { - return match new { - Required::Value(new_val) => match self { - Required::DefaultValue => Required::Value(new_val), - _ => self, - }, - Required::DefaultValue => self, - }; - } -} - -impl ForeachExpanding for Required { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return match self { - Required::DefaultValue => Required::DefaultValue, - Required::Value(x) => Required::Value(x.expand_foreach_value(var, value)), - }; - } -} - -impl ForeachExpanding for toml::map::Map { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - let mut result = toml::map::Map::new(); - for (k, v) in self { - result[k] = v.expand_foreach_value(var, value); - } - return result; - } -} - -impl ForeachExpanding for toml::Value { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - match self { - Value::String(str) => Value::String(str.expand_foreach_value(var, value)), - Value::Array(items) => Value::Array( - items - .iter() - .map(|i| i.expand_foreach_value(var, value)) - .collect(), - ), - Value::Table(kv) => Value::Table(kv.expand_foreach_value(var, value)), - other => other.clone(), - } - } -} - -impl ForeachExpanding for Option { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return match self { - Some(v) => Some(v.expand_foreach_value(var, value)), - None => None, - }; - } -} - -trait ForeachExpanding { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self; -} - fn default_mode() -> Plural { return Plural::One("default".into()); } -lazy_static! { - static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); - static ref KEY_REGEXS: Vec = vec![ - Regex::new(r"(?i)f[1-9]").unwrap(), - Regex::new(r"(?i)f1[0-9]").unwrap(), - Regex::new(r"[a-z]").unwrap(), - Regex::new(r"[0-9]").unwrap(), - Regex::new(r"`").unwrap(), - Regex::new(r"-").unwrap(), - Regex::new(r"=").unwrap(), - Regex::new(r"\[").unwrap(), - Regex::new(r"\]").unwrap(), - Regex::new(r"\\").unwrap(), - Regex::new(r";").unwrap(), - Regex::new(r"'").unwrap(), - Regex::new(r",").unwrap(), - Regex::new(r"\.").unwrap(), - Regex::new(r"\/").unwrap(), - Regex::new(r"(?i)left").unwrap(), - Regex::new(r"(?i)up").unwrap(), - Regex::new(r"(?i)right").unwrap(), - Regex::new(r"(?i)down").unwrap(), - Regex::new(r"(?i)pageup").unwrap(), - Regex::new(r"(?i)pagedown").unwrap(), - Regex::new(r"(?i)end").unwrap(), - Regex::new(r"(?i)home").unwrap(), - Regex::new(r"(?i)tab").unwrap(), - Regex::new(r"(?i)enter").unwrap(), - Regex::new(r"(?i)escape").unwrap(), - Regex::new(r"(?i)space").unwrap(), - Regex::new(r"(?i)backspace").unwrap(), - Regex::new(r"(?i)delete").unwrap(), - Regex::new(r"(?i)pausebreak").unwrap(), - Regex::new(r"(?i)capslock").unwrap(), - Regex::new(r"(?i)insert").unwrap(), - Regex::new(r"(?i)numpad[0-9]").unwrap(), - Regex::new(r"(?i)numpad_multiply").unwrap(), - Regex::new(r"(?i)numpad_add").unwrap(), - Regex::new(r"(?i)numpad_separator").unwrap(), - Regex::new(r"(?i)numpad_subtract").unwrap(), - Regex::new(r"(?i)numpad_decimal").unwrap(), - Regex::new(r"(?i)numpad_divide").unwrap(), - // layout independent versions - Regex::new(r"(?i)\[f[1-9]\]").unwrap(), - Regex::new(r"(?i)\[f1[0-9]\]").unwrap(), - Regex::new(r"(?i)\[Key[A-Z]\]").unwrap(), - Regex::new(r"(?i)\[Digit[0-9]\]").unwrap(), - Regex::new(r"(?i)\[Numpad[0-9]\]").unwrap(), - Regex::new(r"\[Backquote\]").unwrap(), - Regex::new(r"\[Minus\]").unwrap(), - Regex::new(r"\[Equal\]").unwrap(), - Regex::new(r"\[BracketLeft\]").unwrap(), - Regex::new(r"\[BracketRight\]").unwrap(), - Regex::new(r"\[Backslash\]").unwrap(), - Regex::new(r"\[Semicolon\]").unwrap(), - Regex::new(r"\[Quote\]").unwrap(), - Regex::new(r"\[Comma\]").unwrap(), - Regex::new(r"\[Period\]").unwrap(), - Regex::new(r"\[Slash\]").unwrap(), - Regex::new(r"\[ArrowLeft\]").unwrap(), - Regex::new(r"\[ArrowUp\]").unwrap(), - Regex::new(r"\[ArrowRight\]").unwrap(), - Regex::new(r"\[ArrowDown\]").unwrap(), - Regex::new(r"\[PageUp\]").unwrap(), - Regex::new(r"\[PageDown\]").unwrap(), - Regex::new(r"\[End\]").unwrap(), - Regex::new(r"\[Home\]").unwrap(), - Regex::new(r"\[Tab\]").unwrap(), - Regex::new(r"\[Enter\]").unwrap(), - Regex::new(r"\[Escape\]").unwrap(), - Regex::new(r"\[Space\]").unwrap(), - Regex::new(r"\[Backspace\]").unwrap(), - Regex::new(r"\[Delete\]").unwrap(), - Regex::new(r"\[Pause\]").unwrap(), - Regex::new(r"\[CapsLock\]").unwrap(), - Regex::new(r"\[Insert\]").unwrap(), - Regex::new(r"\[NumpadMultiply\]").unwrap(), - Regex::new(r"\[NumpadAdd\]").unwrap(), - Regex::new(r"\[NumpadComma\]").unwrap(), - Regex::new(r"\[NumpadSubtract\]").unwrap(), - Regex::new(r"\[NumpadDecimal\]").unwrap(), - Regex::new(r"\[NumpadDivide\]").unwrap(), - ]; -} - -fn valid_key_binding(val: &Required) -> std::result::Result<(), ValidationError> { - match val { - Required::DefaultValue => return Ok(()), - Required::Value(x) => { - if valid_key_binding_str(&x) { - return Err(ValidationError::new("Invalid key binding")); - } else { - return Ok(()); - } - } - }; -} - -fn valid_key_binding_str(str: &str) -> bool { - for press in Regex::new(r"\s+").unwrap().split(str) { - let mut first = true; - for part in press.split('+') { - if first { - first = false; - if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { - return false; - } - } else { - if !MODIFIER_REGEX.is_match(part) { - return false; - } - } - } - } - return false; -} - /** * @bindingField bind * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` @@ -538,80 +257,12 @@ pub struct CommandInput { whenComputed: Option, } -impl Merging for Option { - fn merge(self, new: Self) -> Self { - return match new { - Some(x) => match self { - Some(y) => Some(y.merge(x)), - None => Some(x), - }, - None => self, - }; - } -} - -impl Merging for String { - fn merge(self, _: Self) -> Self { - return self; - } -} - impl ForeachExpanding for String { fn expand_foreach_value(&self, var: &str, value: &str) -> Self { return self.replace(&format!("{}{var}{}", "{{", "}}"), value); } } -impl Merging for toml::Value { - fn merge(self, new: Self) -> Self { - match new { - Value::Array(new_values) => match self { - Value::Array(old_values) => { - let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); - let mut new_iter = new_values.iter(); - let mut old_iter = old_values.iter(); - loop { - let new_item = new_iter.next(); - let old_item = old_iter.next(); - if let Some(new_val) = new_item { - if let Some(old_val) = old_item { - result.push(old_val.clone().merge(new_val.clone())); - } else { - result.push(new_val.clone()); - } - } else if let Some(old_val) = old_item { - result.push(old_val.clone()); - } else { - break; - } - } - Value::Array(result) - } - _ => Value::Array(new_values), - }, - Value::Table(new_kv) => match self { - Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), - _ => Value::Table(new_kv), - }, - _ => new, - } - } -} - -// TODO: think through ownship here -impl Merging for toml::Table { - fn merge(mut self, new: Self) -> Self { - self.extend(new); - return self; - } -} - -impl Requiring> for Option { - fn require(self, _: &str) -> Result { - return Ok(self); - } -} - impl Merging for CommandInput { fn merge(self, y: Self) -> Self { CommandInput { diff --git a/src/rust/parsing/src/command/validation.rs b/src/rust/parsing/src/command/validation.rs new file mode 100644 index 00000000..c1570d42 --- /dev/null +++ b/src/rust/parsing/src/command/validation.rs @@ -0,0 +1,149 @@ +use crate::util::Required; +use lazy_static::lazy_static; +use regex::Regex; +use toml::Value; +use validator::ValidationError; + +pub fn valid_json_array(values: &Vec) -> std::result::Result<(), ValidationError> { + return values.iter().try_for_each(valid_json_value); +} + +pub fn valid_json_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { + return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); +} + +// we read in TOML values, but only want to accept JSON-valid values in some contexts +// (since that is what we'll be serializing out to) +pub fn valid_json_value(x: &Value) -> std::result::Result<(), ValidationError> { + match x { + Value::Integer(_) | Value::Float(_) | Value::Boolean(_) | Value::String(_) => { + return Ok(()); + } + Value::Datetime(_) => { + return Err(ValidationError::new("DateTime values are not supported")); + } + Value::Array(values) => return valid_json_array(values), + Value::Table(kv) => return valid_json_object(kv), + }; +} + +pub fn valid_json_array_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { + return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); +} + +lazy_static! { + static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); + static ref KEY_REGEXS: Vec = vec![ + Regex::new(r"(?i)f[1-9]").unwrap(), + Regex::new(r"(?i)f1[0-9]").unwrap(), + Regex::new(r"[a-z]").unwrap(), + Regex::new(r"[0-9]").unwrap(), + Regex::new(r"`").unwrap(), + Regex::new(r"-").unwrap(), + Regex::new(r"=").unwrap(), + Regex::new(r"\[").unwrap(), + Regex::new(r"\]").unwrap(), + Regex::new(r"\\").unwrap(), + Regex::new(r";").unwrap(), + Regex::new(r"'").unwrap(), + Regex::new(r",").unwrap(), + Regex::new(r"\.").unwrap(), + Regex::new(r"\/").unwrap(), + Regex::new(r"(?i)left").unwrap(), + Regex::new(r"(?i)up").unwrap(), + Regex::new(r"(?i)right").unwrap(), + Regex::new(r"(?i)down").unwrap(), + Regex::new(r"(?i)pageup").unwrap(), + Regex::new(r"(?i)pagedown").unwrap(), + Regex::new(r"(?i)end").unwrap(), + Regex::new(r"(?i)home").unwrap(), + Regex::new(r"(?i)tab").unwrap(), + Regex::new(r"(?i)enter").unwrap(), + Regex::new(r"(?i)escape").unwrap(), + Regex::new(r"(?i)space").unwrap(), + Regex::new(r"(?i)backspace").unwrap(), + Regex::new(r"(?i)delete").unwrap(), + Regex::new(r"(?i)pausebreak").unwrap(), + Regex::new(r"(?i)capslock").unwrap(), + Regex::new(r"(?i)insert").unwrap(), + Regex::new(r"(?i)numpad[0-9]").unwrap(), + Regex::new(r"(?i)numpad_multiply").unwrap(), + Regex::new(r"(?i)numpad_add").unwrap(), + Regex::new(r"(?i)numpad_separator").unwrap(), + Regex::new(r"(?i)numpad_subtract").unwrap(), + Regex::new(r"(?i)numpad_decimal").unwrap(), + Regex::new(r"(?i)numpad_divide").unwrap(), + // layout independent versions + Regex::new(r"(?i)\[f[1-9]\]").unwrap(), + Regex::new(r"(?i)\[f1[0-9]\]").unwrap(), + Regex::new(r"(?i)\[Key[A-Z]\]").unwrap(), + Regex::new(r"(?i)\[Digit[0-9]\]").unwrap(), + Regex::new(r"(?i)\[Numpad[0-9]\]").unwrap(), + Regex::new(r"\[Backquote\]").unwrap(), + Regex::new(r"\[Minus\]").unwrap(), + Regex::new(r"\[Equal\]").unwrap(), + Regex::new(r"\[BracketLeft\]").unwrap(), + Regex::new(r"\[BracketRight\]").unwrap(), + Regex::new(r"\[Backslash\]").unwrap(), + Regex::new(r"\[Semicolon\]").unwrap(), + Regex::new(r"\[Quote\]").unwrap(), + Regex::new(r"\[Comma\]").unwrap(), + Regex::new(r"\[Period\]").unwrap(), + Regex::new(r"\[Slash\]").unwrap(), + Regex::new(r"\[ArrowLeft\]").unwrap(), + Regex::new(r"\[ArrowUp\]").unwrap(), + Regex::new(r"\[ArrowRight\]").unwrap(), + Regex::new(r"\[ArrowDown\]").unwrap(), + Regex::new(r"\[PageUp\]").unwrap(), + Regex::new(r"\[PageDown\]").unwrap(), + Regex::new(r"\[End\]").unwrap(), + Regex::new(r"\[Home\]").unwrap(), + Regex::new(r"\[Tab\]").unwrap(), + Regex::new(r"\[Enter\]").unwrap(), + Regex::new(r"\[Escape\]").unwrap(), + Regex::new(r"\[Space\]").unwrap(), + Regex::new(r"\[Backspace\]").unwrap(), + Regex::new(r"\[Delete\]").unwrap(), + Regex::new(r"\[Pause\]").unwrap(), + Regex::new(r"\[CapsLock\]").unwrap(), + Regex::new(r"\[Insert\]").unwrap(), + Regex::new(r"\[NumpadMultiply\]").unwrap(), + Regex::new(r"\[NumpadAdd\]").unwrap(), + Regex::new(r"\[NumpadComma\]").unwrap(), + Regex::new(r"\[NumpadSubtract\]").unwrap(), + Regex::new(r"\[NumpadDecimal\]").unwrap(), + Regex::new(r"\[NumpadDivide\]").unwrap(), + ]; +} + +pub fn valid_key_binding(val: &Required) -> std::result::Result<(), ValidationError> { + match val { + Required::DefaultValue => return Ok(()), + Required::Value(x) => { + if valid_key_binding_str(&x) { + return Err(ValidationError::new("Invalid key binding")); + } else { + return Ok(()); + } + } + }; +} + +fn valid_key_binding_str(str: &str) -> bool { + for press in Regex::new(r"\s+").unwrap().split(str) { + let mut first = true; + for part in press.split('+') { + if first { + first = false; + if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { + return false; + } + } else { + if !MODIFIER_REGEX.is_match(part) { + return false; + } + } + } + } + return false; +} diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 2b32da55..e3675af7 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,5 +1,6 @@ pub mod command; mod error; +mod util; use wasm_bindgen::prelude::*; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs new file mode 100644 index 00000000..317cec3d --- /dev/null +++ b/src/rust/parsing/src/util.rs @@ -0,0 +1,145 @@ +use crate::error::{Error, Result}; + +use serde::{Deserialize, Serialize}; +use toml::Value; + +pub trait Merging { + fn merge(self, new: Self) -> Self; +} +pub trait Requiring { + fn require(self, name: &'static str) -> Result; +} + +// TODO: think through ownship here +impl Merging for toml::Table { + fn merge(mut self, new: Self) -> Self { + self.extend(new); + return self; + } +} + +impl Requiring> for Option { + fn require(self, _: &str) -> Result { + return Ok(self); + } +} + +// required values are only required at the very end of parsing, once all known defaults +// have been resolved +#[derive(Default, Deserialize, Serialize, PartialEq, Debug, Clone)] +#[serde(untagged)] +pub enum Required { + #[default] + DefaultValue, + Value(T), +} + +impl Requiring for Required { + fn require(self, name: &'static str) -> Result { + return match self { + Required::DefaultValue => Err(Error::RequiredField(name)), + Required::Value(val) => Ok(val), + }; + } +} + +impl Required { + pub fn unwrap(self) -> T { + return match self { + Required::Value(x) => x, + Required::DefaultValue => panic!("Required value missing"), + }; + } + + pub fn or(self, new: Self) -> Self { + return match new { + Required::Value(new_val) => match self { + Required::DefaultValue => Required::Value(new_val), + _ => self, + }, + Required::DefaultValue => self, + }; + } +} + +#[derive(Default, Deserialize, PartialEq, Debug, Clone)] +#[serde(untagged)] +pub enum Plural { + #[default] + Zero, + One(T), + Many(Vec), +} + +impl Plural { + pub fn to_array(self) -> Vec { + return match self { + Plural::Zero => Vec::new(), + Plural::One(val) => vec![val], + Plural::Many(vals) => vals, + }; + } +} + +impl Plural { + pub fn or(self, default: Plural) -> Plural { + return match self { + Plural::Zero => default, + _ => self, + }; + } +} + +impl Merging for Option { + fn merge(self, new: Self) -> Self { + return match new { + Some(x) => match self { + Some(y) => Some(y.merge(x)), + None => Some(x), + }, + None => self, + }; + } +} + +impl Merging for String { + fn merge(self, _: Self) -> Self { + return self; + } +} + +impl Merging for toml::Value { + fn merge(self, new: Self) -> Self { + match new { + Value::Array(new_values) => match self { + Value::Array(old_values) => { + let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); + let mut new_iter = new_values.iter(); + let mut old_iter = old_values.iter(); + loop { + let new_item = new_iter.next(); + let old_item = old_iter.next(); + if let Some(new_val) = new_item { + if let Some(old_val) = old_item { + result.push(old_val.clone().merge(new_val.clone())); + } else { + result.push(new_val.clone()); + } + } else if let Some(old_val) = old_item { + result.push(old_val.clone()); + } else { + break; + } + } + Value::Array(result) + } + _ => Value::Array(new_values), + }, + Value::Table(new_kv) => match self { + Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), + _ => Value::Table(new_kv), + }, + _ => new, + } + } +} From c8c92468b044760c2e257363e1fb04e7cb7875d8 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 15 Jul 2025 17:43:34 -0400 Subject: [PATCH 06/79] working merge Created using spr 1.3.6-beta.1 --- src/rust/parsing/Cargo.lock | 380 +++++++++++++++++++++++- src/rust/parsing/Cargo.toml | 3 + src/rust/parsing/src/command/foreach.rs | 6 + src/rust/parsing/src/command/mod.rs | 52 +++- src/rust/parsing/src/util.rs | 17 +- 5 files changed, 440 insertions(+), 18 deletions(-) diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 7bd4ac17..9ca5a7e2 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -11,6 +11,56 @@ dependencies = [ "memchr", ] +[[package]] +name = "anstream" +version = "0.6.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd" + +[[package]] +name = "anstyle-parse" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys", +] + [[package]] name = "bumpalo" version = "3.19.0" @@ -23,6 +73,12 @@ version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268" +[[package]] +name = "colorchoice" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" + [[package]] name = "darling" version = "0.20.11" @@ -69,6 +125,29 @@ dependencies = [ "syn", ] +[[package]] +name = "env_filter" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0" +dependencies = [ + "log", + "regex", +] + +[[package]] +name = "env_logger" +version = "0.11.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f" +dependencies = [ + "anstream", + "anstyle", + "env_filter", + "jiff", + "log", +] + [[package]] name = "equivalent" version = "1.0.2" @@ -219,12 +298,42 @@ dependencies = [ "hashbrown", ] +[[package]] +name = "is_terminal_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" + [[package]] name = "itoa" version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" +[[package]] +name = "jiff" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49" +dependencies = [ + "jiff-static", + "log", + "portable-atomic", + "portable-atomic-util", + "serde", +] + +[[package]] +name = "jiff-static" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "js-sys" version = "0.3.77" @@ -253,26 +362,60 @@ version = "0.4.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94" +[[package]] +name = "matchers" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558" +dependencies = [ + "regex-automata 0.1.10", +] + [[package]] name = "memchr" version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" +[[package]] +name = "nu-ansi-term" +version = "0.46.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84" +dependencies = [ + "overload", + "winapi", +] + [[package]] name = "once_cell" version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +[[package]] +name = "once_cell_polyfill" +version = "1.70.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad" + +[[package]] +name = "overload" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" + [[package]] name = "parsing" version = "0.1.0" dependencies = [ + "env_logger", "lazy_static", + "log", "regex", "serde", "serde-wasm-bindgen", + "test-log", "thiserror", "toml", "validator", @@ -285,6 +428,27 @@ version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "portable-atomic" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483" + +[[package]] +name = "portable-atomic-util" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507" +dependencies = [ + "portable-atomic", +] + [[package]] name = "potential_utf" version = "0.1.2" @@ -342,8 +506,17 @@ checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" dependencies = [ "aho-corasick", "memchr", - "regex-automata", - "regex-syntax", + "regex-automata 0.4.9", + "regex-syntax 0.8.5", +] + +[[package]] +name = "regex-automata" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132" +dependencies = [ + "regex-syntax 0.6.29", ] [[package]] @@ -354,9 +527,15 @@ checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" dependencies = [ "aho-corasick", "memchr", - "regex-syntax", + "regex-syntax 0.8.5", ] +[[package]] +name = "regex-syntax" +version = "0.6.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" + [[package]] name = "regex-syntax" version = "0.8.5" @@ -427,6 +606,15 @@ dependencies = [ "serde", ] +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + [[package]] name = "smallvec" version = "1.15.1" @@ -467,6 +655,28 @@ dependencies = [ "syn", ] +[[package]] +name = "test-log" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e33b98a582ea0be1168eba097538ee8dd4bbe0f2b01b22ac92ea30054e5be7b" +dependencies = [ + "env_logger", + "test-log-macros", + "tracing-subscriber", +] + +[[package]] +name = "test-log-macros" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "451b374529930d7601b1eef8d32bc79ae870b6079b069401709c2a8bf9e75f36" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "thiserror" version = "2.0.12" @@ -487,6 +697,15 @@ dependencies = [ "syn", ] +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + [[package]] name = "tinystr" version = "0.8.1" @@ -538,6 +757,54 @@ version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" +[[package]] +name = "tracing" +version = "0.1.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex", + "sharded-slab", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + [[package]] name = "unicode-ident" version = "1.0.18" @@ -561,6 +828,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + [[package]] name = "validator" version = "0.20.0" @@ -591,6 +864,12 @@ dependencies = [ "syn", ] +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + [[package]] name = "wasm-bindgen" version = "0.2.100" @@ -649,6 +928,101 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + [[package]] name = "winnow" version = "0.7.11" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 2049c27b..b1651def 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -4,10 +4,13 @@ version = "0.1.0" edition = "2024" [dependencies] +env_logger = "0.11.8" lazy_static = "1.5.0" +log = { version = "0.4.27", features = ["release_max_level_error"] } regex = "1.11.1" serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" +test-log = "0.2.18" thiserror = "2.0.12" toml = "0.8.23" validator = { version = "0.20.0", features = ["derive"] } diff --git a/src/rust/parsing/src/command/foreach.rs b/src/rust/parsing/src/command/foreach.rs index 55bd876e..3d160396 100644 --- a/src/rust/parsing/src/command/foreach.rs +++ b/src/rust/parsing/src/command/foreach.rs @@ -63,3 +63,9 @@ impl ForeachExpanding for Option { }; } } + +impl ForeachExpanding for String { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return self.replace(&format!("{}{var}{}", "{{", "}}"), value); + } +} diff --git a/src/rust/parsing/src/command/mod.rs b/src/rust/parsing/src/command/mod.rs index 329c9a9a..bae29e9c 100644 --- a/src/rust/parsing/src/command/mod.rs +++ b/src/rust/parsing/src/command/mod.rs @@ -3,11 +3,12 @@ mod foreach; mod validation; +use crate::command::foreach::ForeachExpanding; +use crate::command::validation::{valid_json_array_object, valid_json_object, valid_key_binding}; use crate::error::{Error, Result}; use crate::util::{Merging, Plural, Required, Requiring}; -use foreach::ForeachExpanding; -use validation::{valid_json_array_object, valid_json_object, valid_key_binding}; +use log::info; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; use toml::Value; @@ -21,8 +22,6 @@ pub fn debug_parse_command(command_str: &str) -> std::result::Result Plural { return Plural::One("default".into()); } @@ -257,12 +256,6 @@ pub struct CommandInput { whenComputed: Option, } -impl ForeachExpanding for String { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return self.replace(&format!("{}{var}{}", "{{", "}}"), value); - } -} - impl Merging for CommandInput { fn merge(self, y: Self) -> Self { CommandInput { @@ -434,6 +427,7 @@ impl Command { #[cfg(test)] mod tests { use std::collections::HashMap; + use test_log::test; use super::*; #[test] @@ -539,14 +533,50 @@ mod tests { left.args.unwrap().get("to").unwrap().as_str().unwrap(), "left" ); + assert_eq!( + left.computedArgs + .unwrap() + .get("value") + .unwrap() + .as_str() + .unwrap(), + "count" + ); assert_eq!(left.when, Plural::Zero); assert_eq!(left.combinedDescription, None); assert_eq!(left.combinedName, None); } + #[test] + fn merge_nested_arguments() { + let data = r#" + [[bind]] + name = "default" + command = "cursorMove" + args.foo = { a = 2, b = 3, c = { x = 1 } } + + [[bind]] + key = "r" + name = "→" + args.foo = { d = 12, c = { y = 2 } } + + [[bind]] + key = "x" + name = "expected" + args.foo = { a = 2, b = 3, c = { x = 1, y = 2 }, d = 12 } + "#; + + let result = toml::from_str::>>(data).unwrap(); + let default = result.get("bind").unwrap()[0].clone(); + let left = result.get("bind").unwrap()[1].clone(); + let expected = result.get("bind").unwrap()[2].clone(); + let left = default.merge(left); + + assert_eq!(left.args, expected.args); + } // TODO: test more elaborate merging scenarios - // (e.g. nested argument structures, proper overlaoding of lists + // (proper overlaoding of lists // of when clauses, array of arguments that get properly merged) // TODO: errors on missing required fields diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 317cec3d..a30317c4 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,5 +1,6 @@ use crate::error::{Error, Result}; +use log::info; use serde::{Deserialize, Serialize}; use toml::Value; @@ -10,11 +11,18 @@ pub trait Requiring { fn require(self, name: &'static str) -> Result; } -// TODO: think through ownship here +// TODO: is there any way to avoid so much copying here impl Merging for toml::Table { - fn merge(mut self, new: Self) -> Self { - self.extend(new); - return self; + fn merge(self, new: Self) -> Self { + let mut result = new.clone(); + for (k, v) in self { + if new.contains_key(&k) { + result[&k] = v.merge(result[&k].clone()); + } else { + result.insert(k, v); + } + } + return result; } } @@ -92,6 +100,7 @@ impl Plural { impl Merging for Option { fn merge(self, new: Self) -> Self { + info!("Merging `Option`"); return match new { Some(x) => match self { Some(y) => Some(y.merge(x)), From fb69f995280507d97c4474b085bdd091c8911499 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 16 Jul 2025 00:38:37 -0400 Subject: [PATCH 07/79] more coverage Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/command/mod.rs | 87 +++++++++++++++++++++++++++-- 1 file changed, 82 insertions(+), 5 deletions(-) diff --git a/src/rust/parsing/src/command/mod.rs b/src/rust/parsing/src/command/mod.rs index bae29e9c..daf9ba97 100644 --- a/src/rust/parsing/src/command/mod.rs +++ b/src/rust/parsing/src/command/mod.rs @@ -516,11 +516,13 @@ mod tests { name = "default" command = "cursorMove" computedArgs.value = "count" + prefixes = ["a"] [[bind]] key = "l" name = "←" args.to = "left" + prefixes = ["b", "c"] "#; let result = toml::from_str::>>(data).unwrap(); @@ -542,6 +544,7 @@ mod tests { .unwrap(), "count" ); + assert_eq!(left.prefixes, Plural::Many(vec!["b".into(), "c".into()])); assert_eq!(left.when, Plural::Zero); assert_eq!(left.combinedDescription, None); @@ -575,12 +578,86 @@ mod tests { assert_eq!(left.args, expected.args); } - // TODO: test more elaborate merging scenarios - // (proper overlaoding of lists - // of when clauses, array of arguments that get properly merged) - // TODO: errors on missing required fields - // TODO: can expand foreach + #[test] + fn merge_nested_array_arguments() { + let data = r#" + [[bind]] + name = "default" + command = "runCommands" + + [[bind.args.commands]] + command = "step1" + args.b = "bar" + + [[bind.args.commands]] + command = "step2" + args.x = "biz" + + [[bind]] + name = "run" + key = "x" + command = "runCommands" + + [[bind.args.commands]] + command = "step1" + args.a = "foo" + + [[bind.args.commands]] + command = "step2" + args.y = "fiz" + + + [[bind]] + name = "run_merged" + key = "x" + command = "runCommands" + + [[bind.args.commands]] + command = "step1" + args = {a = "foo", b = "bar"} + + [[bind.args.commands]] + command = "step2" + args = {x = "biz", y = "fiz"} + "#; + + let result = toml::from_str::>>(data).unwrap(); + let default = result.get("bind").unwrap()[0].clone(); + let left = result.get("bind").unwrap()[1].clone(); + let expected = result.get("bind").unwrap()[2].clone(); + let left = default.merge(left); + + assert_eq!(left.args, expected.args); + } + + // #[test] + // fn expands_foreach() { + // let data = r#" + // foreach.a = [1, 2] + // foreach.b = ["x", "y"] + // name = "test {{a}}-{{b}}" + // command = "run-{{a}}" + // args.value = "with-{{b}}" + // "#; + + // let mut result = toml::from_str::(data).unwrap(); + // let items = result.expand_foreach().unwrap(); + + // let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; + // let expected_value = vec!["with-x", "with-y", "witih-x", "with-y"]; + // let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; + + // for i in 0..4 { + // let item = items[i].clone(); + // assert_eq!(item.command.unwrap().as_str(), expected_command[i]); + // assert_eq!(item.name.unwrap().as_str(), expected_name[i]); + // assert_eq!( + // item.args.unwrap().get("value").unwrap().as_str().unwrap(), + // expected_value[i] + // ); + // } + // } } // TODO: define the "output" type for `Command` that can actually be passed to javascript From 41f1e4cc91a3670e299b22d0cbf353f129b35a1c Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 16 Jul 2025 00:39:06 -0400 Subject: [PATCH 08/79] wip test coverage Created using spr 1.3.6-beta.1 --- .gitignore | 1 + mise.toml | 42 +++++++++++++++++++++++++++++++++++++----- notes.md | 11 ++++++++--- 3 files changed, 46 insertions(+), 8 deletions(-) diff --git a/.gitignore b/.gitignore index 5deb6df0..5f1f1b56 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ node_modules .nyc_output/** coverage/** coverage.json +*.profraw # unit testing test/temp/** diff --git a/mise.toml b/mise.toml index 5da6480f..ac224c1a 100644 --- a/mise.toml +++ b/mise.toml @@ -1,14 +1,16 @@ [tools] -"cargo:wasm-pack" = "0.13.1" node = "20" -"npm:pnpm" = "10.12.4" "npm:typescript" = "5.8.3" "npm:vsce" = "2.15" -rust = { version = "1.88", targets = "wasm32-unknown-unknown" } -watchexec = "2.3.2" -"ubi:haberdashpi/simple-src-docs" = "0.6.0" "npm:c8" = "latest" "npm:http-server" = "14.1.1" +"npm:pnpm" = "10.13.1" +"ubi:haberdashpi/simple-src-docs" = "0.6.0" +watchexec = "2.3.2" +rust = { version = "1.88", targets = "wasm32-unknown-unknown", component = "lvm-tools" } +"cargo:wasm-pack" = "0.13.1" +"cargo:cargo-binutils" = "0.3.6" +"cargo:rustfilt" = "0.2.1" [hooks] postinstall = ['pnpm install --frozen-lockfile', 'pnpm exec playwright install chromium'] @@ -32,6 +34,36 @@ run = [ dir = 'src/rust/parsing' run = 'cargo test' +# TODO: split out coverage tasks +# TODO: use the following code to handle specifying the object +# $ llvm-cov report \ +# $( \ +# for file in \ +# $( \ +# RUSTFLAGS="-C instrument-coverage" \ +# cargo test --tests --no-run --message-format=json \ +# | jq -r "select(.profile.test == true) | .filenames[]" \ +# | grep -v dSYM - \ +# ); \ +# do \ +# printf "%s %s " -object $file; \ +# done \ +# ) \ +# --instr-profile=json5format.profdata --summary-only # and/or other options + +# TODO: generate an lcov report I can merge with the other coverage output +[tasks.coverage-rust] +dir = 'src/rust/parsing' +run = [ + 'RUSTFLAGS="-C instrument-coverage" cargo test --tests', + 'cargo profdata -- merge -sparse default_*.profraw -o parsing.profraw', + ''' + cargo cov -- report --use-color --ignore-filename-regex='/.cargo/registry' \ + --ignore-filename-regex='.rustup/toolchains' \ + --instr-profile=parsing.profraw --object target/debug/deps/parsing-af68333d2940d566 + ''', +] + [tasks.build] depends = ['check-types', 'lint', 'build-rust'] sources = ['src/**/*.ts'] diff --git a/notes.md b/notes.md index e3910c67..adb55985 100644 --- a/notes.md +++ b/notes.md @@ -68,10 +68,15 @@ Integration test debugging: a. in this early phase, we don't worry too much about providing detailed error messages (if there are easy things to do here we can do them, but no UX work, etc...) - [ ] start by implementing parsing of `[[bind]]` - - [x] basic parsing - - [~] merging defaults (unit tests remain) + - [X] basic parsing + - [X] merging defaults (unit tests remain) - [~] foreach expansion (unit tests remain) - - [ ] refactor code + - [X] refactor code + - [ ] initial coverage output + - https://crates.io/crates/cargo-tarpaulin + - or look at https://doc.rust-lang.org/rustc/instrument-coverage.html and use + nightly tool-chain with + - rustup toolchain install nightly - [ ] validation that `master-key.prefix` uses `finalKey` - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region - [ ] validate by checking error reporting From dfa7b09e4fd0e4b6e0732aae74a57e2b776021e9 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 18 Jul 2025 01:00:27 -0400 Subject: [PATCH 09/79] working coverage output from rust Created using spr 1.3.6-beta.1 --- .github/workflows/ci.yml | 7 +- .gitignore | 1 + mise.toml | 111 +++++++++++---------- notes.md | 10 +- src/extension/keybindings/index.ts | 1 - src/rust/parsing/coverage/parsing.profdata | Bin 0 -> 548224 bytes 6 files changed, 71 insertions(+), 59 deletions(-) create mode 100644 src/rust/parsing/coverage/parsing.profdata diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7785ae89..0454df93 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -5,6 +5,9 @@ on: - main tags: - v[0-9]+.[0-9]+.[0-9]+* + paths: + - src/** + pull_request: types: ['opened', 'edited', 'reopened', 'synchronize', 'ready_for_review'] @@ -44,7 +47,9 @@ jobs: run: pnpm install --frozen-lockfile && pnpm exec playwright install chromium - name: Unit Tests env: { COVERAGE: 'true' } - run: mise test${{ matrix.environment }} + run: | + mise test${{ matrix.environment }} + mise test-rust - name: Integration Tests if: matrix.environment == '' env: { COVERAGE: 'true' } diff --git a/.gitignore b/.gitignore index 5f1f1b56..20c52b0a 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ node_modules coverage/** coverage.json *.profraw +*.lcov # unit testing test/temp/** diff --git a/mise.toml b/mise.toml index ac224c1a..1a3e9abc 100644 --- a/mise.toml +++ b/mise.toml @@ -10,10 +10,15 @@ watchexec = "2.3.2" rust = { version = "1.88", targets = "wasm32-unknown-unknown", component = "lvm-tools" } "cargo:wasm-pack" = "0.13.1" "cargo:cargo-binutils" = "0.3.6" -"cargo:rustfilt" = "0.2.1" +"cargo:rustfilt" = "latest" +"cargo:nu" = "latest" [hooks] -postinstall = ['pnpm install --frozen-lockfile', 'pnpm exec playwright install chromium'] +postinstall = [ + 'pnpm install --frozen-lockfile', + 'pnpm exec playwright install chromium', + 'rustup toolchain install nightly', +] [tasks.lint] run = 'pnpm exec eslint src' @@ -21,6 +26,7 @@ run = 'pnpm exec eslint src' [tasks.check-types] run = 'tsc --noEmit --project tsconfig.json' +# TODO: maybe consider using colons and figure out mise task hierarchies??? [tasks.build-rust] sources = ['src/rust/parsing/src/**/*.rs', 'src/rust/parsing/Cargo.toml'] outputs = ['out/**/*.wasm', 'src/rust/parsing/lib/*'] @@ -30,39 +36,38 @@ run = [ 'cp lib/parsing_bg.wasm ../../../out/parsing_bg.wasm', ] -[tasks.test-rust] -dir = 'src/rust/parsing' -run = 'cargo test' - -# TODO: split out coverage tasks -# TODO: use the following code to handle specifying the object -# $ llvm-cov report \ -# $( \ -# for file in \ -# $( \ -# RUSTFLAGS="-C instrument-coverage" \ -# cargo test --tests --no-run --message-format=json \ -# | jq -r "select(.profile.test == true) | .filenames[]" \ -# | grep -v dSYM - \ -# ); \ -# do \ -# printf "%s %s " -object $file; \ -# done \ -# ) \ -# --instr-profile=json5format.profdata --summary-only # and/or other options +[vars] +coverage_options = '''--ignore-filename-regex '/.cargo/registry' + --ignore-filename-regex '.rustup/toolchains' + --ignore-filename-regex 'rustc/' + --compilation-dir src/rust/parsing + --instr-profile coverage/parsing.profdata + --Xdemangler rustfilt''' # TODO: generate an lcov report I can merge with the other coverage output -[tasks.coverage-rust] +[tasks.test-rust] dir = 'src/rust/parsing' -run = [ - 'RUSTFLAGS="-C instrument-coverage" cargo test --tests', - 'cargo profdata -- merge -sparse default_*.profraw -o parsing.profraw', - ''' - cargo cov -- report --use-color --ignore-filename-regex='/.cargo/registry' \ - --ignore-filename-regex='.rustup/toolchains' \ - --instr-profile=parsing.profraw --object target/debug/deps/parsing-af68333d2940d566 - ''', -] +shell = 'nu -c' +run = ''' +if ($env.COVERAGE? | into bool) { + $env.RUSTFLAGS = '-C instrument-coverage' + $env.LLVM_PROFILE_FILE = 'coverage/parsing.profraw' + + let object_files = cargo +nightly test --tests --no-run --message-format=json | + from json -o | where profile?.test | + get filenames.0 | + each { |f| $'--object=($in)' } + + cargo +nightly test --tests + cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata + (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> + ../../../coverage/rs_coverage.info) + + cargo cov -- report --use-color {{vars.coverage_options}} ...($object_files) +} else { + cargo test +} +''' [tasks.build] depends = ['check-types', 'lint', 'build-rust'] @@ -86,15 +91,16 @@ run = 'tsc -p src/test --outDir out/test' [tasks.test] depends = ['build-tests'] -shell = 'bash -c' +shell = 'nu -c' run = ''' -if $COVERAGE; then - pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath=. \ - --version=insiders --coverage --coverage-output=coverage/unit \ - --coverage-reporter=json -else - pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath=. --version=insiders -fi +if ($env.COVERAGE? | into bool) { + (pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath . + --version insiders --coverage --coverage-output coverage/unit + --coverage-reporter json) +} else { + (pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath . + --version insiders) +} ''' [tasks.test-web] @@ -108,18 +114,19 @@ depends = ['build --web'] run = 'pnpm exec vscode-test-web --extensionDevelopmentPath=.' [tasks.assemble-coverage] -run = [ - 'c8 --temp-directory coverage/integration/tmp/ report -r json -o coverage/integration/', - ''' -pnpm exec istanbul-merge --out coverage/merged/coverage-final.json \ - coverage/integration/coverage-final.json coverage/unit/coverage-final.json -''', - ''' - pnpm exec nyc report -t coverage/merged --report-dir coverage -r lcov -r text \ - --exclude node_modules --exclude out --exclude .vscode-test \ - --exclude src/test - ''', -] +shell = 'nu -c' +run = ''' +c8 --temp-directory coverage/integration/tmp/ report -r json -o coverage/integration/', +(pnpm exec istanbul-merge --out coverage/merged/coverage-final.json + coverage/integration/coverage-final.json coverage/unit/coverage-final.json) +(pnpm exec nyc report -t coverage/merged --report-dir coverage -r lcov + --exclude node_modules --exclude out --exclude .vscode-test + --exclude src/test) +mv coverage/lcov.info coverage/ts_coverage.info' + +cat coverage/*_coverage.info o> coverage/lcov.info +lcov-summary coverage/lcov.info +''' [tasks.test-integration] depends = ['build', 'build-tests'] diff --git a/notes.md b/notes.md index adb55985..1600d9dd 100644 --- a/notes.md +++ b/notes.md @@ -72,7 +72,7 @@ Integration test debugging: - [X] merging defaults (unit tests remain) - [~] foreach expansion (unit tests remain) - [X] refactor code - - [ ] initial coverage output + - [x] initial coverage output - https://crates.io/crates/cargo-tarpaulin - or look at https://doc.rust-lang.org/rustc/instrument-coverage.html and use nightly tool-chain with @@ -100,10 +100,10 @@ Integration test debugging: - [ ] convert any bind elements in this overlap into markdown table - [ ] actually replace javascript behavior with rust functions - [ ] CI - - [ ] setup CI unit tests for rust - - [ ] setup rust coverage - - [ ] setup CI and merge coverage across rust and javascript - - [ ] maybe: https://github.com/mweibel/lcov-result-merger (research others) + - [x] setup CI unit tests for rust + - [x] setup rust coverage + - [x] setup CI and merge coverage across rust and javascript + - [ ] verify that CI is running and coverage is showing up 4. Move palette from quick pick to tree view - [ ] get a simple tree view working (just show one item) diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 91d296b5..f571107f 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -686,7 +686,6 @@ export async function activate(context: vscode.ExtensionContext) { mode: ${parsing.mode} priority: ${parsing.priority} defaults: ${parsing.defaults} - foreach: ${JSON.stringify(parsing.foreach, null, 2)} prefixes: ${parsing.prefixes} finalKey: ${parsing.finalKey} computedRepeat: ${parsing.computedRepeat} diff --git a/src/rust/parsing/coverage/parsing.profdata b/src/rust/parsing/coverage/parsing.profdata new file mode 100644 index 0000000000000000000000000000000000000000..b440dc25316972779e417501b15be2c79cb38ea2 GIT binary patch literal 548224 zcmdq~2Vfl4)jkfdMDI2b2pyaN1`^oWCW#WPk!4%9iKHBQ|#YJ)r*HP<=Z@9d}$$e%NvYd7QSh^SE!d{CnGT ztHg&Pdpm!Z-$o)!PL-c-*-8GcE{lxVLO$TtP38AIsyEMBUwq;I{`ei`2v@7|Y$Y#? z?0%Vizt7Z-f2h7+x%VdG(>-b+`>F3|T`wPaoBDgAI!2Om2D9q#->Ku0ySEUZV(RY( zb-#~~-BNtBwfg=a>ig(Ua%4Q8)6_h+{Y-wZ{*1h!KD=5lzgL$>{;j@G>Hgmz8t{Ep zr0SUmx47r6$f;+k5e-*IqorxWyta}tq1;eP=NogKiSe~CsON|Ys&S+C~cB+0#O}xiQ&@;c7c+lcqJ9a;aU-<`WpnPCb zsEVw&WbP4vIOFRRN2s5ySDMf;VV)d-|0|{X(nX9qSx&e2WHl{aET$J2;*Y3aV-&X8 z=(k5y57hDqRN)c*(!7d3=oeVT3vwEfeN7mogwxL8R_6 zC;H2|p4wtM-<8D^@n)dacrjNyE*~|<<+U24G2WFe>vhI{umAMR-|c$*xsruMB0P?u zqkDW+k?n>&^q&uI{mqE+>Q#oDBgC}I;dQjm?N28%qv!U{Hd6C*`Fvr%7R?lT+jIGJ zxll}YWZV0@lI3DLlNF1A;iimKsa(vaduvPObUEAE-%~q9eGsSUQ;pi5LMC0#<-4@_ zc=c&YPcD;fp@-u4L_6+~(5IAXDbzgqZe~UKHGRcwPk%>NOSEJ&{l!wQkZXq&8(OTPkS}Kk%7SGywqz$XhzSD0 zOD=%B>5~jSPXDzUE%n{A<3?k&QIE|w_FeVm5qC_#cnhW$#nE{&Y`bs!-4D(m^_PwQ z!-Qq62JQd0QkSBbuqDa$_VtvAZfcAgHE!HsO<0IzB+)3ZXnWX-#-brhiW6LGs%vQ@ zaM}7Lp|n@B8hBA!q9}-kSBbAy)RCGb*rTpZGx}+L8nvikm_{B;8r8Lo@qGErYg^_G zy_pv&m__cgva|fJqgPFysunP6ZW-FtT3hA28WNj#rlq-OXLRCV|B(YS1;bPe$ShB;3bs`2G5vX>g~1r zW?!A&*|gv^&z#Y&O9t;cW^>HUXwM}LUzS$mB!6tp6zCN^vaZnCS<04;bfCU+%~9uV zy3gfHdih0mvED&^vKD{u6}6ilwfvU#W_n&kExboLftFL-SuFG#V7HRZ*3^z#SkvA& zF`rLidt%>!N!Nhi_onk5#0JHOrhH$2xltc!oHXQTpZ#?1ZZmjntncy=d2H)PhWE|h zWS{m!9{rj6$+2&Q3N~IJqvsl%r`6PAGiUSjjGjVQSGJgv2TX0usL}g#JssI%Em2i2 zpDW*RedkXO*lyT){9Ieu5QDL;H)T-{FX|~%nloGAI z-KmD2#);kYjoNe`OAk8Sb=21A>rE_kyzv<6c| zC5^0>f=&5MPk$*lFWcQHBp9St z+34;TpXJ=eo6~*bhTtv9-u|9)F4dCl%cje$tAORS2-nvnq+%Kg#$rQZ?S_I?(Dd*xw>Nj;=znm>OFCZQv_KT)Ipyt4# z59qO(#y0U!E?M;azZ!Wn?8@6&9ht3FMfUCM+G>|qyWg+z+1JgbI9|!eBxDOzi;c{} zY|Ev4atpJ?cs@ISv+d3~^O`+o|AHSJ#7?Rs2RyUs;d|Wv@*79`Jh-h?6c6^1^J@D* z;gwW_mFmT$WR=QFoSyy+vYnS4d%|=3?)t!(u<;$RqW#XU&dYzempakLC8Xv&h!UbU zh*&dFM5r|}He|<-UB?@qmei|{46f=LJsv-Mqukr?|AuFIgj!=h zSmYO-bn=E@b^ho#JF8P`)hRGBQ(pb%-FPGc*dd4NtqC2zqN+UcR#N`JrU7--UNW`re@+|Ywn(frb zb8Z^>`Eif&W^c1*8@j*Pa{lT=a$dTppHQcSk(@>!6Q#a%zU6S^)Z;e${MQUw{#)IS z6+8*)@h~D0H|WXd@fp@YYbSlX{ny3)rzF)+w(VC5j%11fp@mOUO2_rlTX*3`JPsJQ}d(i7vA0ykAY z29Iha=*EWsH0h~=P~4IWp}5g?lMT9#j-*pr-w>0+DC}s8{b#+V+Ynlq_3TD*bN3TW zG8jZuCWUG{yV3pzsd6zlFPGNhJvr#fz!h`&(51#$Ta=@wL5NY=zff2NXvC%E%{5wE zNxjr@cBA|UuWpAX)ZUm1vEfC~qy2Ib@hf!KLQ&Highzm(hUp%tAqYKMFH+yP*R_ih zx5YAE#*8tvDTOiZhJ@?Nxn3YM>E1rEs&%c_pZ?kiVDFldxl&(GdI2HZQ5Y%l1CM&= ziObhJkJ&h*#BSDE|M9R-Z#?&`MSdo-VB#HXV5pN$`^i3sem(a7j_vrtZr;s2yFRkK zGy2}ebraNxT+%}_70=Y9O5M;`I|OK+%+Wm2h9mRWoFq*v7mN-d(e&#Ne|h~={f7>l z$`XY=T09NzBaf~sGAi1<)vSYuo;FIIGF%-coF9ewr?v15Fqr{8_axNFVDHknw0J2C zoUg+WHeLsoXW^+!ubFcEBW*lOLCaGe8NK+S|1RII|MBhDTCzFV2=mrZJ$qURYlX{Y zU7_|0{`FIteRMu4*m8ym%A~*np>dI5n`5*^$L@dn`yZf4!nMgE3xX3|E21}qLhjH| z1(&lsK*qbJlG9*rH150Z4|~n|-3>?Z91jhc%uXmV`QG$ZgtOgC8D%Wh|*Dja%V$4mkeR+OgEkwXuh*_^-E9l!f-qR zuMZP{Rb<@C`KM&BY~FK<`pJ&Z3hFPVa-%w8ef>?kQP-U=b+;D_^YigydVVb4-k+HR z2)j33nqz>~X3~A>Os>2j2t+vl%<0+6^ zYAV^A>^g(_<<&qjyYN-G5v$Qo#H#X58HPq^>ky7$1(eK6HyI_;ZZgsn38Cu&y2B?u zQ3Hvk(`j~Hk7mPUMY?94>)7(qCOruSFz9DJp7yYWAf2cx()`S4-&UWrVm=e8C0EIw zs0f#5gO!m$v0T0olT$b3Wt|zyYexpM0&pVCnKshHYvFwj@=CLdZKikK;tSpD)(DKg z!zg!W*+#2nFY_kAJk^Ee)GaWmXgfBUDEw zM4mWw<_Tx-->dk5MGzz)VoK2pQbS4KO^JXF=?Gz;QNXxCGM#Clw3_ov`wTE6yF*b=(g<)-Vlrt^FY^x)gE_e*i^-(El)%A@H2m8%C_XZekUh z>st9hOdjOt2ASZdWsZ!H8j~IyZz*lHQYV^U66z2_UV{7?t%^(&*puv!BZ;Rc7Lrxi zZM63HH^M_OjtE*$*5em^Nqzx*1D2v|aU-534@@`69^c7}6wmOOtIkLfJwC>0qTpfO7=f^QA2Fsp|g0mRI_>I5#^JXy!i5rhBsTU z@Dt^09^wLCrGh@lk0sx99e5EN!*)>Py4yj5@UW}BA{=I{Gw=umEeLpyY(0u(i0~$S*m!^PX{(wVwWfcsG6N8NJn6V-d} z_8t>qkO^HCXWUb~0;>&_u;7A_aKZNL;Aj3&&OE|%8nZh$3s4giu0Df(cmWx0K*A@YJVR=TW zz&zsfG17Kp;PZ+-2=$~$U$^!{d;xyMj}A)Lx{TQuELgo_=%p7hBjc6j6>}dg%Ad93 zZ{x3B{)1QdQxU(OQv0E8t?F7)lKYSakamJ9I!^sp(-Wr9l9*m~ff6O0OO7 zS*hCKg=+0)0vyyu%DAtfrnDiwW709E$4AM9!WvHZS?@{i^_CAr$f(qEEoqRPC&j^l z;gAQosgP$BRibO7K^e`YClFgrWh}Nj8f=w*f$o5h^0W9z-x6EJK%8tzV2 zJvm?`glB{35k6H3Y{%x8=sqo3`C$2*ngQV@glUD5(?1weE%vb!2^V9=B+=#KS)MN% z0RSk*j`eq`C8H6?LDL@Uvq;-r77gI9G#k!nKD?C49JH8tkfD&bRz2Nk;GgM&&4V{5 zz`T1CP57r#0VjIAnWC49a!=PyEqB&RdjV&=WA}nEyY(WSlRkWH{loGXQ4WGk{?2FaD4covLkq?$#%M7}so6{V^j9?1aI{!1FC9d}U*q^IO5TpEPZ-wq z*IDgNtP7~T8U0ALzc$FpNIDtj1Yox;GxZzB~ODnJ=nyU`6@UI8?z3> zsn2AxrIJ=dQO-uTCrc?RMk%Y@sk#O^-kUDY$-<*GsXLuVvdYMGIV~UJ^=OjJhbNB0 zR>>iUR2RQc(VZ@OcEwQ#)U-0T$6}MkC@%ode^q48%GIYgJ~s2ykJL|n>S!hM1n&!a zX|V`+XJ`U7(|2zC-`^ zVC|Bb!Le>a| zg6Ga!n4ROKR|o7TlI4apiv&kId~oVCpES#%53uPCmzxl)`PEwCDq279^%{S9+tS6)6lsI z)3H4&b}++pFS2jClb<^vF8Px!i3waMZ9M;*{U$FPKJ75xIhtd@2I*M?GBUBTxX$DGZ7T}Z~Zv#Id6N&Te$egEWPW*}^HlcYk zP+Y`zE;ZgbV`1{I$MYJE3s|G-$Z;z--20q)8(grx4{pDvL2M2K6ZWiWVDj3*KRq~N z0w_Af4)1odPpQ~cCJFqR1jgw`Q(#uQ(G+PJw^@d9Mn&VpB!q385s)K3v$+JHyhw|t zgh={Tk2k=W1pqTu<_*Anz}Lu+jA0dB_h^jDrzPVCn_F};Ol6!Y31+kzy{Oe8WWE4x zIop{Vpq)z@0H)!K33u5oG;XmRJ{q|b;s+pW*U%dWcMi%XCvVt`;nWgCs`PJPgEIR72^Ec)PyY)be>m1*=^n`!>@{4ac zo!WYIrCjIx9`Rb)`VpiT%$}yZNjxl>mnj>(PP$BGOu5YTrI>Os9&eU!5PeidPF`}= z;cvWg-BG)Ggaa8IgQC0N3A(l1`plI=6&Gz>7*`tS=1OZBVdP~z4m{QyVHB(m{QUS2 ze`zdx{HQ-E#=eFCI`NrM{mTQ-y6|>iFg6r6*Jg%I_e{@pBXT7u$Y5>2*wHR97P-=D zFZqD);L|Q~p+r5xi9KlSSc%4tccQVlt0^pXZK|Osqb3?#w1m!72om}Q5(gjUXYrA~ zB@GTEaiX#63caSD(O78NCK}twdWS$`r;>;f4<=Qkk*9#sSd3gxjumKZuNRHQm?^Xv zmy2hKm#}}qXe_i$Gwp0@r6BBRI|z$NZ81v6&KT`+RIq95(tON6SzuI0&X|Uo>q9R7ffmf-{bPo{>;DCX2}CYPZWF*cFIy}pC~mR6F+rK=6$>W>EDf$Q;{*rdK;xo&8_PLM8!@y;J%UW*d-$tx}ASNgFB=W66*;#tH5<9z-Gz;zy3U zmzPD^0wu~snmRmk4Tv2Y=+jZpgzS zjemS;(a;-wjO7Y+)-_>5LIP9lS7na!TF&dJ6Oax4#nY`qcJxcLSmF{CmIz$Ag(QWHh#5Z2IqFw>L=GsUdx zT0b@><)Z*vM}nRDh8(zMq@o)lQw2Hx#M)wTG^aHDhuTB(LQPyKqwGPq_`- zM&fFu*^V+=Q;`Qb?iPj;|wPF3nyLm`ST0@^7iqHr&^2?wzQ013IP@2`*DJbS^|nX z<~R#TzJz>#sq|36DUmRkL}@K#!jA4Kw5NNZHTXk26YuSPDM2m@qB~`hOJmGB1TJgptuN59vq`S^`PH~o*# zPN)yj zbMpH3yQ1~>`fm>PP9B`bvfhc$-c@r0X$WnlR+Rc1pUu~aNC=}Ro1fUWadKE}z^pM) z&(BpyetdOg+2VyK$8JBTd`2J#S>rN!btX|0LqVqOy3jt_EnSaEq$7+(Vgq67E<(zj zIhMLM`~N4}N7=1?ba;s^1sUiJ&J@}QNYJHy5K(%x4=B&E5|n7Tds3h)s2DgcNc-q^ zY9A%3eUuH>K02Uh_bKh8Y}Y=aY_i-&EYt2PZcI;lN1a&3S zv7lUbhBq4+Nm4II@TB2KI zDb|sIL8$=4Wkf$l@mOg(`T}ECT`!J-g_=yaCY2YtlvIZg(N)OioIgc;GJl1Bh`<9X z2PaR_5>4t0d19kpQ%6oKyfF<}ly|Dh7|y&acQ-h&`=I#P128yHA|YYtQXIakqUIJ;mZE*z0wD) zHa;LQGMr)Ot@fXl)73g(d_h~(j7GAb?qs@6dd+NXb?ais&$>3oWBV~>G4Zp8Q59M7 z=C~>M?RE6WT;y!HI%SP(YOxbrFf_bJsEXJYvRZBK#R@gr0-Zx@Og`AXmqm$l{j^Ci z8rOnLK8f@sFfZRKF0o!uL583(;i||jOM3e^{!99oi`8OTD*@>^Ls=lcwxaYZ+4KD? zd0}s@MP9n_0FE%=2)h>KM58=Wd^*({psZNcn31Ko+5kRh?H!Nb52%G6ybLGPqO!<6QGgmf9 z+o_7&Hfz$4il-&CpL$j_lv^u>NQ97~N};MhE&)}91@TISLVSqI9o%n#6V~xc`5<#h zxpu7-*}OJZr)e_036UsvV^@cb;D)h+h2!muA4>jYQNzPr)WO<7K(RAu07H7U1lzdkmxifmi zicfyB_x;EDXccXx*^m>yTUwcrG)oBBi;D8@eFcn7CMww-0eTCRGCEBmq?*Q6LEvBt zg4T}y=Wkzo?8;wo6@o}m0kk`#rC)#W{E!d0$lVA_JX8`oAmeYjM}zP&Z`rcLPwQ4U ze$9Y|d+O8!JO>t8)sedVG0Sw~=dsMuTQ- z)THOnI_%;T&0xEiT_fc2-8CY*^Uj%LrZuYHZB)3X(4(tx4n`a~=Q61a(7)f01od;pgjO&5#%*qIzk zPQ*PXba1Nis>q7+<$Hbl+oRT8s3?I)S#Up@i)&s<&JU7&za<*MzT0ic|>WUp;E%@AP7Z&!=nE@!GCMdKa_*O2eXYM z#La0zz(F8h8^Aalv4}YZ6bpTv5m}lY=xyDwx3vC# zf0}m+D`wnPO${ONVA0bPlg`-t&Y#?~dbK*2cc6(S_!5$0)5t=Uj2K%hH2Y&ri1-<^ z?xc@gZ6AOZQrks5txd}{t!P4p3A?^Q|dDF|EJf=>y(t}~IQr1&| zv0~RHq~jKo25C*OGmB#`Qoim`ico+lHYbEiaKbuMQY4x9I3WS5yT}BghXnys@Z7{v zMlTG2KqEA`E<1@8Q8fjGQSlR9IwsDc^2g#7hoTZ6Z+!doyMO;`(kXi@^w=y0A50R@ z9Y5-oVRzrQ!dqB86vC)5eqZ9|ss|U*jj5W67ZijPrm3uX0i(5y-1nBNb4;-}az7aE zdw%hfoBsUXK^Hx!Hn_FXA$6NeT=B|NVR!J7L9G(!z^oC7=Pnj(uM><@w5Ute z5fk6lH8Ji%OW3T6l;Vc5^1_tF7HFAzEWm;CmKEPYa9`TE@{svw4PS4Q)0yQ2t3EF* zIi>%?Qr%(yQl~m*p)!W^J@3g!FF_tJd)*hgb^TD3E;K`6AQV)cDhE74?yjK2T^_2 z6APF>L6kdP$<|p81>QfghzW@0r6ng{9MbXbu0P%7ij^KuSfxtq_uZE)slSp~N;AGN zkgfoEyM+*u0KRn56`g1YG6Lu-+3%n${Aq@f5Mi0p%+f+w)^TpD>>)`JqtvZr&7whZ zff)@-<*X>s0tme;(1O141X`r(4WiQ;@^quNro1j7&H^{EM|r~4tp-c%5k9yY2wF-R z5>$`7nL7ZVDM?33=%5`ySJr}W{FR^RK%924!D#c=>rmor#MA9Bq6ClM%!Rx$?LZ0*qjVy2o|~+g zZb>6@x3kl?1|Oh3i3_Q6 zHj+(XtJ|Ye{8M+h@(XbfTQfxYHstFTLr$Tve@CHL(@>Wi$0^kR7W*PG!`SA$Mc2Ku z@h`696#+u>73fYFMZy*8hKSseG9s7WP(5?-fYkO zONV(1r*XC@AB3Aj#>QGEjRp)krlVIjW>h)$eW`& z^7^cwP2B9VOTXw*rwlhYhtPI>_l3e$>`iWca8++Ea*zY;#ka0Lde-X`I5p2S9(mL} z+SenqZi#pQ>tAbQGFAd{xZqBj`~Qu}I0(3{V%&Y^*Xy8g2z}V0ZU=WTUi)UG^Yql! zV~%*(j|$pK((map7-igq*tb4xAO-qBL2#rM(1G|miS;DMK=dQJ5RyqtOc6m5Bh}wH z3)YLQU?@IoG4Y40yQ{_KqtTTiD!L6|PoU?fvLvacChc}DR$5Sk*WKvPqyIZppIYNL zdwl&+^43o}SX2ZXjc>iVc-Z1|?%Xu)nTLunGUi2;+LoO^=kUu1D_ub%7IJuu$>T$l8SZ0nMn`S)n z^5bJBEdR8Rk-!J}1J9y5GE=XL{C&lXBeom=Mad7CCX5I@o#!IKdE&yv?A9`71!`@f zC}kifgeI>ZnSi-WgAj}Hu59_QrGd9<{`lWddBeLwa_iaePdan2p`v%H#kr@*SwipzK!JNaL0N&+AcYIi_AA-UJ6RLHh$;jXYgA-g}HuYZ) z42eW=t8#q9)#VATOQx}2ikV9;4=Xo`;8u9ilcJRhonZ$G#EaloF0{vXkyGxW==AgD zGp}u#H}qy+e>VwQ>;K`3XC|H1({%V5J`BIDlnM4sFmTMV3Ua-DYd=Ggv;r3BJS#q^ z!gj$|Klh6#@7w;OdVZf^dj2^2?)$&qa<5akg%q8fWKGYFH zR$7OBUZmX@q#^Py398Ye1dLB{6;z*c(VOXrMS!;1NV`^gV$szR?J%S#mg3$d1J<=# z;eo|3Ir`) z9gzL|tc$kYL-E+*>I@NA@c)GJN-y!faI@&ib}FHSe=wl`sl!F+($X0t95C*`CDjJO z(d5Djhof1xxp!Jsgj$bMvfH~v3`xo4C=c&1`nP}Y--{OzoF1bF@e8-U+ z_*K_U!zk3xECW37%O~ zWv7CT6>@Kg^43~H6uvf#<4cP3RyfB6Rt5b!D%W9jBh|p)Bk+35#@7$o^1kQ!6@s?JO77_}pM%(6*|MZ1~o+IZYe<<+i)Mvn#mmAXbsxW-uL8*e@bA7|zrR zX5Q-W!j4@uIpT6p%u+)$0M@E?QX-h8Dj3!;%HMl>FHbOQmjqeuqv|AS^Mp{b>pMgv*Z||_%)gGBIzu|SWcqTAgXwY zV2r3RWQCETB@1~&FmaK(_Y=BE6pR}z%o9n$9fKyMA^7%@je?oTK?}* zel`H-mjS)6tir0?IE)b&} ztPhkPN68F@Q25j;N}!aPld2?9aj7B^|AMddWXxV-0hL2!axm3iohce&$1n?40!4m%|sj+ zN}SPk1bLRxkOx=O1lqMuTAaD1(w9tUT|@SO`rYwV?Ql@cx1C8aJw$C=B-S$ zTGAt_%?bQZLOVkRjf8RP^N-hEckctA@o<9m#UW??e$&N6{_=TJ4QGTpid|2U(m}gk zbOxi@FhqN>M5!;GANxQmfA;o;p}e&j72I6ibgDZ3TOIjeZSAeAR(!bW+xxubSEs0< zl%3yIu5X+W!(&F^?z3BneBAS=&fe&Q7K1Ro1zk&ogjVSGKt1 zrOh`vU`+fFo)12H2e8f1cXoQCeMS3M>L+V?Dviby%0m)qxMjIjiQd902!)9hk38XkM`T*TI1uIvw6ybox0o3J@1(}et*y#jA2F96xyK~zd$5Q zPp{3S`{AVRFG+qG7X1@Yq<74?qn91p+BAkycs}xC^U zzwaJVvFf3^pgPNE-tC!fN>%hBp#-?KQ?z)ztI#0J0?t9~Vgmd{$PWbY%CN4Irpa`_ z3%?l5PU4AZE!juib(y=%cD)~KZn66Fi+S#)2U8^i~%=;%9T zk0;}1BD3iK|r#Hhu?rST}nbe#sB1xQtI`o4t|cJA{BW>oz>xVjJ9>e=11=N#FZyA;ky<7 zAo^m$ir4=*`qK3a&Ta4^tTnYt1{&)+vOv&`-hMI z@k(~9Eq}kgx6NXuy7%{84a*2xqKHEgnPrQ~iVqr?1}krFe>R`V)>7e~Y=P40csS7YA|V7>u~606PiX%7&-Sy557V{0v%AJDi+*$U-&#~ zrz40`ba7FIs^D_w|gTWu9!bqPw^^!cs^r>X|3Rv{LtoY~ZKae2ad-h>QJ z1DC4RMQN05M^v9II&fq`l?dXYWCbLzyZb)|^QO_4z57;c`}8+{;IsC`of6W>^BNUq z@HmCTAri2;&_Q4|ysl1*l{gl;V(U9PRM=qUd?~D%uI6f{D;eqFj=^A9SPT=MS&nXm z9?{Xkq3W2{>Be~{?|ja*75}`RMek3U*Q=worN-VkYtsiOAOBzfm{>Wd0oWRqox_|Z ztQN~fYOuW74yWsXSg`*U{A{;I!q2XbG~fUAku!$==6V10KU!2O4IY?%hi8My3IkOM zCO?oVIO`18Q~e8Z12g$dpJ3FeKeX69>i4Y(f3PJZceRW$MZv5ePCECDlO}C-55NC5 z0dwE{>;*F)UVhzYBh~LVW@cur2Lqcl`KkFuYHp18Km_4*@j2Dr-`SZhp1Wi2Z!iAm z)z5hhL2FPInegmoqdwVb{$sit#S(RtFtFTIsZ3jT+^F`3cwxY(N#{%D1wGlM2#ywy zuB%7A$p(s*u1lAU&MulTkm%}1|E?!KJo@V)>W=O-NcDBa2gZ^sy}+G(!PhbURYfM= zc-?2a-gDPEC#jz-+)~Koihv`)%@wr`0k8IH8xmNmkNbu&gvoZSyP}QtGLzC*Tz1H! z$?tySc^T-?veJLBZDda;MUGiQq?005u0Df4$_kYA54tc<(vo?2NenQR6zHAH;Wi|>;YKl~-k{^>v(!&ECdl6Z!3P;Hr>UGr%!s$9yR;O~8PauxD=cV)2mRy1Q9JDX z>7Kkff2E$!NB2mpBQy5+cZc@HPj>Ucz~FBl1gs#F2_r-`CwS3?zcLDP+h>J-?~3bt z-e4J7;wP#jv(_2+Z*j_xW__{60qR8i1PvNk=S8zg#e}G~lRY#TS>ut&UWM-XrL&;b zj!R#qy|I=tW)y|4Be0YH8=z1~CP&|`Bo$~aE;dpV0*z4Xuo!3-syjNZyjaESkBh*oR== zR-P$&kkdUX*8?r7Mr@jFscWN+(*4Vp{F?zYRukMu9uFU_ab<3N?!+%QT=wQRenJ8@ z2P+9aGsAo9C=%A_F7y|>6$ho)3Q5Csa9FldkUJ6vr-s$5*E|L5fzbxWFCmvhf|fok z*eS<*x#bgNt2Dypu7zjb!nl_#SAS8)vQEJF)^i%ljtSgN3pRC@$ zXCrl=FvmmK?-u!Y-rqQE!>(6$`ibI)!)+s7H!-oQ&XiCkWqAAAM8u+LA?M8bX3J^l zH|Y%38Z07~7T;<$Eo??fQGPM99uUUK4ZSh4)0xYtBhPkqWbXYPi6e#_x%dcW!a1c6 zdA2Ly7gmHUg1cMObFy3*6=s^?CA5W@kA$PJyz-K}Xg?!d1bW*1(N=y?!LNIoVbZwldDyiZ= z2!*$r6w(=JYu6;=+VDhGoJCK}1?t)$f!Gv;Yj;K9s88(@8l-(3^2G+LU7{x^hzF`+ z$^M@hcWk_=r*qRmyq$Pa^eyh9!X@5O%ip~Na1<`lQFYo%Yg9MYYvFE|7t%8@09qwG z+Kkd8ScN2YGNcKXCsPwau`XDaS^zN6-3>(ViyNum#C5IR)F>Bc>a_^%BliYwrp%Po z6qoVX-Kb8M`_v0ycgs{v+|GeW$0iu_#_jalp4W9oSXXg-u6VcdHk~{4mt8F#w_nPY z+?a`zrqWglO@`&2=j^{MH?4!3k#=g99k4D6llozOx6u#R#R%7ayUMxtOON&BN2+b8 zA^4KFVR5ZD3>rv)T8d)h;xmS!kF*v08Rb*#2d97o*mpHTDXHlt5frXA1j_b2pl? zfWWys`jdaG%)8 zDbhhjOtuKe1|uN$1@kEi@U|a`4#>^WHPl{4?2m}CqV&-*&rC_(uzcHl`Nds1eCF#j zrB_9cnY+B>*gY1l9IJk_Hnfbe46;w+Eff*bq4(!{kOGoa;o5#1vi*wOC#UGk%+w(^ z$ayfiU@&m6@8MmrVCO$!0 zuEw$ia@lQe5~wlYRIvrn84=Tvf{c|H1{6HSJ?#Zgab2q%BsZ3&76|hoF6FmoE;8L2 z_%0q(J54?YdkCYptFBZG5Ow}g{R^Etfg;y-2o#wvN+3H~UFf)rURT7kh?rDuJ=+t^ z@_JBP+~xHc91A*n_rxi0>F1oZ^4=>N)KAX+Nrj?>z;(9{OJ>mauO~sJuf-t6G$|Y* zN8e&OtNw7oix+F@70euiH|AM$hrBTC@Vma`dN_80xVF{zY4VVDWd#ydgs*ua1i>mp zA+lIlMGTza*?91U1Uu_7e4wn}(%F7Un5UNq6ggt^5LPjYwwYOxe#{w~(CLuJ1V;uD zAco(;^PV1Dh*UmdjuQ!nuw@BH*!ly8 z24MfMgLC}ivb{lkYR)}z*$9G}0@DHY;v`A5WWg}zc>1dZ<;|Y`R_fu!i|h70&~K9E z9rON&K(!LD52FYS za0wt1tBfsZ;Sjv^;j$`h>Cv~zwe+OD1j;H^dcaRG&2g`;z)0ZgmpS)@eNZV#J{Amp|k?IV(0`tNv&OQiuLv;22H=Cd@&G0lpP}Sz~8NMT%k@TQO^Lk z6}TW>M-Kw9As;0Np<)#vPbDGpP=W-cZL|);LrFQefOM;B%tn}hR7HMUzi5-=&witN zk^0HWKa#=xgDq@!XJE9@Cw-k7F71SHYXr%N8f^j=DfOVBa}bp9LS6lZA8m8^IA(=& zT${;yl}p}Aygp~ojsLV3ZGm~!;WrUjCL;>6LLn1>c>6{Km-Br1&V&YB-s#?1d%h>h z!_U)$GNH~WQcrKjsN{Ha-K=ZAr%;O91!qn7mG|#(z|r5V9LG6#ETcr?m8n?!0|tbq z2~V0Nni}D{TBn@?xA`@625Lz67`;ZGqB_Vuh0Z2X@x%P?Tu)Z*3m+zEMcI2DNfqxV6h$3;H{pc; z``wf%x_1-I?HbW%tQ4n+l^Ku=1w-_x)6tN7%<>o8-&%Z@#`vroo*tprfWO~a{mtL2 zKPx`)YF{<<;F+hL6+N=7t{kq8R$z*tS--?uiY_3qu85@}&ta2@-wozW4EG5GZmJ#U zqfl$4>|XeB^ZnO6{mcW*vxB0It0LE)F#ENp4-;2qJ*ESkR5St~!$Ilmif0E8)2-Jh zMMVmfr^xgJY^Ufoye`%0&*gh^@VS=L?LApdYZ8BnU{j%}Q*9~78IHePthHj|MvBSc z#Elai#0>}*dx^&`8ka*+T_}xjfDzsh7H?XvLtPl<;q}aznD&^osvmL0 zw&$pD*ZZ3(+f|Xfw3_$F-qF3&-X3bIbkh^PI}|n3^%Jh6g>AfbnZ7Ft&S!JR3vQ|6 zVkAh%7nlrkc^$hpR`hIJw}Z%{w7cJW=!OUHjXr#vS__*@AaPz9t)X(UMQaIi1y)R8 zh<=>gkKNy6Iz9c>K_`u&ybOd(b7A5GyrIEoXa5cb#J2n)N=E4Bd!5n9bI-W4Vl z;Z}4SP!uT~h#sICf1Q$$J{9efp6mkX>F}iB8a+vg#X6l~_qN!7)>H6b$_?(RQ)s)3 zWBY=Rdp#vynNHkvvFelc)=&JcZec-D#Rzo*G&(^Q6%vIgD@P;%K&K_!mra)e?o}A1 zUE5KByB53G{18R#BV9~7aIFYhHRhL8AS<2`3XI3*hO977@T@Qj76^~~; zx;nwegvmRPRSc5$TC|iY^kuvH(?y{y0bYqtp>IahH$r{Iwnmj+SHOng&lKySYsgrc z3B3`shqWRFfx>Xk#as7jUUspW zipgVhkEts1&A%2|b-vIH8cngKV!PT0VAVy{L)s&e@wb5n8q5V3zXk%#ix|abAT`z`OLlhRt=r>KGROn zrmBiOtNr=fO}2XSHg9k~XlM;l5(Fz41J4ZOx4;Z_S z|2lLLRTZ?3gQofg2q3;|V+z_6LdD6+K9gcOI^b|f8c$t6^VVx0+3rN1ZASKa#d)c# zBY)C%KcM%umww0PEgd_yxm2sv22Ve`!5g5b8*5NM3U+XLTs~@y%R|GVT#}B&rA^zX zO1tr}-1*QvtUo>b!Mx64(?6fA#%m3V%#g515JiH3ricV%iBf+%$k52A^94zchS)V7 zzyS&uPuw%o|BEgjP%u@#I`>y^|KR2=uRGaiNLFgH4|7wV54lsZGf+hz{aL#t9O@%A z9U8G%eO%OLt6uFWpd=LLVP}1K{JUS|%nl?kx-ep%)~d+sHy(3y>lRNwo$-AO^4~za z2&k2ilI2LnE5sY~ik*AHtKb;yOrwcm%}8}rfB$5l^X_3cB{$-!4u+53u3tJTbK8ZN zt_#stBF39VVF?i*YmlUakhMhHPd+^Kr|lnXa6FHSkM5096?tdwWAAM7P5t`y-l-G% zv1uNMP9GeN)6zvMNEnU6$mx9Gi63><-?=+K+O08KtM}IvR(u)7nSjpnb1vjAM}`H)oZ2o5|FNUMm+7pQEr$ zJFfowX4lueJ&)&Wp7~(;f#>Vp$t?>Op7!G#Scus(8k)J*O2A^Nx*#Y|#8IE^6#elcw-sfW1m?WDW?soqfnbmG)+Y*oyGIxNXHj zQbSomz=J(td3>5jL$K#u#wqGhGJbB>R^yZyEUkk^yQnG<}+Er>1 zn&2$z9FBVicOYva3Zyn~uE``49+WHst#Ya3_~D-OJ@ZU^!R#$U30%k)DLd_OJ+{z; zdU91=FTsDA-aIz^v#Y+oTm9r9cw5CdKgMc7Xz&HEm3shh0~+LNJyBV$ClBpkZgcl~Ok>F%pB{1f%)?G*4#~UT`||&te9EJ@-1pharRpb(M=DYh3W4X$00^vd{?3J(K9=oAa4)lJQ#$U;}PV=AmlhYMxx-f{lqQy%{MoVVvPD`pPIM}Aj6 zTC6w{J9O{)r)+uLgB}h?Kv$)9s#yaNF79j*8Q$3PW);9tT#Mka!9zb>Q80s%0|T)^ zpqFByKDwsmc;|rILBO%BdoRjui&!gR+*)mG^w@k`zXdg=Aag533N2p%pCPFbEfx^i zXzTuhU%2}VwU2bh>WlCwSQ7Fw2W-*^RSJRWZym5l$I|!zHG?TX2tBEaR1JIW@}bfF zx~}n30dThORwt674u8s4%jH&WWR|$#t)UTn{~w~txU z_V`0zH7ai4;PI?}`L7nhf<7uw2DoM@y!{m4u{+M5TU zjur>pw0-gXO>6G@kSENV4$AeVhMbV(ZhVJS;>lQ33ft4BlsiWCmPNg`$&xjBR}tse zjVcsTvjhwhC^1>S;tDM)ioS{ZuFz2VrQ-kHU$D%LVF?DU$ z@>ycr)4qQGV)YXCv6*3hJ}`-0VYSpMR7OE{t%~?5hsUe<3zFq@9UL02L>jZ#WO#IP zcNm-P_ORKR!CY1_M8B{?M`nQJ#c;NWh({S;FIlNiR5QAO`?FndqD%&XXNXx(CS1xg z{5tM9VAcY8ZTZM+Tou`3)xY!Go_uZ%cdoZKMy2}G_r2P6Ws4;j#?KkxsgrE)CSod& zRsm_a07L`_5MwM6)$*aEyg&O7*h?=|Dr&xMuc)mC?BT<16^d%o(d}6;Q^oEebg8!q ztSS6N`zF@SN*wh!APs-g1KBp zoDpbW5akDI(DOmQK2L+Zl;@>(3L@lXV7=R=(Z{5!juyoZdG7po{`~VDe{hug#o|k# zSToaoaHg3;_*o#+td&et_KA}Zex=Ah#858`R$}%GUtFh8_f#I_E#8Giv`kTYR_5{>a#uK zmcqBM+2uw3gT`;q;4x%f%*$fHJ6G>M=Z!~C{Ah}28i@f{I*Ewkr%9woXHhcO-&~ro zeZ&37zcVz-gJO7|$Hs%Ij_el8Y4;vF^yF>Ssn*0)s>cXW!;$Y8%1Wn%Y?&$U9kceV zbdYETPscp*#$@MOVF@V670*D}k}~kt_Itng?h{#aQq6vZE^6Ct^}!b$bji%m-}kID zZ5LJI-h(KD(8#zH+eB)_-tdEm?!$JUy?xn0}RCeMcr+kT^^&A**%5XEBf?x?HKR~P!dxq3LP%B{v+ihCj0$7&cwG`e9$cAfQWHkS3=Wvl z8e}~w>I#i`yauYKMW0#QP1#XM{7OF}L#GyT8Ym%4wXdiMU4v2IJsXt;+;?FOIN5J$ zz&M%mMS+@-0vtzmCKV8?)h)~x3koVC8=LCEk=`oCDBjXX2sqVs6!c4>|A~49;GQ)= zF_5JyUXAPp{3?FrNppj3sN}_`I0D1twH~XFV?_Aq=9X2FAD_MF?q`jA?Y#3nTN}LN ze_j!*GujlLovNQwgAP^+QWESIGiKRa1ZxX^C3R#uP!-v$eTTC*AJ}8ohkkNk2CZx; z4|eK`v8Y{hG=M`zw2n9iycdCL zsN|GD`E+96$dWe0@sY=@zSE+JJ5^mMpc>DI2uB!(iibx2yl1Z`DbotJ7PT#wnLCIm zDlS03+&+oy5De+i&ZDBZEuQcE+JTdb(QsuyO>5{cfo|mOap5gjFW$3$&zm?yH4?0% z57&pDIQ}Q6{ArcnMrbQ#nREMzITPF>iVCsT+X*&BdxpR?Q+lCb$|MOUP$bQpG8@ou z;E@fQrhgpU@*7s2*uBO($J#Rcoc-F#pJWE!oaUJWvZwpS6wuJZ(!AJvh&RQO`nd^7 z+54!!C-dPw|1>L|2j>XJm!9;<?HgVFN&o({L zkB;T;^5fSfQIf#)!pWKU&EkhLX62x01li4_HqnMq!wf`y2hrnyExcZS-7=Ry^t1EJzBA!h}Gcf08_@I-Oxp z3KR2BnNJRl&wf#(6o~`4b~>aEl8WY*PM=u3+$_vs7IkKNW_qoTj9R+1u+Ihe#<|mn zMXz%0p~?EL{8|`=O(7e*$vw?$zpv$-`Iv-pxK&+hBA@G;-;q@9STn46dCUhWn(apZ zISPvl_3_;C^KbA>t0PbNC_VGxg-4WL8L7UXrH;-r3PBOo?gnViVAJ@qziL=MW0R5m zEM{izqk5$05Of~juR79H?5o@6_BSS6tgdy!43PRUZ@+;SbkazHCxdN&| z_ES1nF4e+ZfR0rt*3w1v0nLI20+qByORw5s_C@a`8C1DTjXmdje}2oR)ipbxxz~cX zSFb~erLuae!Z?C~&4S*v=E(O`zw+ATFST3gS`cw=uQgGA#d8{-y` zgRSid8riRce_n3#umWkXwK4bpVIIh8ZqwS z_VT+`V%|W!bI{y!*tGRt{P&^X9HV|3u8xwsQK4wTAAGG`F3tF0V8qapCIVigB*efu=&OrlOpzWnpE{=VC?A75cs zTMG&bs)|foHTJ&Y%X@EUXO%@t0y+#W+HNl-)k+-$D)PemBu2IxdaKGlzklZaL{ zZ9HG=&f9N_X49Xx!^{`CseQD}1i7LeXc+CR>4wA0EaRHInkCvw5mKDUp?*3;XadkA z-WG@TR-2JE7)o`r_fomD7Qrf{7pLM1nX8+MFBMRRVkB;)tWS{^A9xQ|MW(mk+;!`E z_sm?RwyR^^760(|J9gM1-}8iE&J*zoEQos&Nhw%{^#RB}t74`Z8q>+mU^wVUbq6L{ zvc#F_C~E0(}b&wtC~*Mx6#E_@>ic#iB-=m`v309KUIAgYY72oHP|BWAss_0d`D)*rI-$?9EXtGE@ZY1u6ty?ka zC&PM|-~70VP|hX~%bO5^%(@hF{h{aQm(u ziu*VOO657Yz_O5otEHf08uN4IZbM}$L-nWZM1RNreOv!Nv+GZuVp$ep3tJ7v)VQi5 zM$6>~+@5J4!?=JoN^*`cuk^&&$I1&+h0ac77>K>Ax>7**DHu8VJ(%4)r=IZJzhv$- zfxuv;tNrbLE?<4jJFjo8HmEfUAti_!eV}c-@Dhvn=AuSW5CrxE6G z`iWsvTuas!Bo_C05#*^Xc~$WUAyCo5!}$n*2e0x?CR$u)BRdHeow)sAag7iYDFO|# z`gkYPC~VbJjpny@Q&75B>Gl2nt5gO=k55q7qJ@K)0;l5>mh&8=Ejo7p)8EgmW}_;| z^|?W$dsXMlU!MNX;e8&3j+kFtDJ32jN?4{Bl#D7n1OSBC6Q2@V2n+?{Lj=61jCi$x0O6UY7DKjiz zbseUw;_-Oe_(CR4MOd{u)ZZ;qI6f4Im(4flc?t54b{F+|nOQsh zs?B#^z^#0Fl>&iaF=069-7|%X&X3RL>qMxb0r(}z$p5fs{~tVm*}Na~xPGRd%Lm?= zRgwI##E%Q#R$std*GWEdWP_kGVqjK=okU~~ynMUg?RwTlW^s&Q<)F}hSLdWhfBKQ1 zXH%*uP=bQ$KPws$Vak-CB{W-q(1WFzkZS0&Vnqkh$0D@sCp%AFeDUEg&E**jj_oMk zbloTU4evQ>tj}6nb%82%x1^luZl&^qp6sQ+xpMlH-)(+9k0p5iO0mL+3qHMOJja4K zohNH51y!P(#K9=|QBb=B^%5J=--1A)y}(Lfkc~S217xOdP=Uu`euy|lg15_P_^#sA z$BU4d>K3O&b?7waM7##3@OO zS1~;DA``NTFjUvsDk>q&v30g+k~k`nd$3Eq-Wb24c(~rw{wQNzkE5Nvm=a2NGnJ?s z)if4AA`-SnC{g%q^|~J8z}9dEz!db+BLV^rYBsy>!lKuUuwTk8!)a=A{jBuC_85)Q zJ`nXBtJ^hRRwQ1jlB#$k9fmhOQ4LH_A!txwe7YGx%#C{SeqtVA9ApVeN_d7XfA<*y zJKW?Hjb*P z47c}}VrD3%7{5+OTnl1fUHZ<6ulMb(PO;RH|5q#pNCHJ|K48FX zH=D92>^g7|mMddWwpyKS+kz-cx_}3YCM{-Yl7FXgU-?2EmQV#$FI!ID2QFzI8Z9$k)uwdOO1!`12 z1nUhm5$9t39+WQ8=-!x8PPTE-h8CCoSP)Hw4_zdnpv;l)BtdxlOV7`e%c`W zbMb|Jk1+p53{pCNLR?a?t^VExYZG#_uYWrVae`3ZKj~=W}U1QrxPDSV#&FL{e zn2icXyZRJZ+A8zdP{S+M9>QaBg3IvIn}S_#)U!ZxM<44dLHSOO$Pfpw(#Lu9<+NH> z_bTv) zPSj+RlW*dm9RnB#LedJd^oozny5Pc7UL14Dv~!pZ1?Rb*y|iJyotC}z?}0+ zbuyKO>X-q41WD91iq9n(!We`{j;L=vjiXzj#v+S3O-c>cy)FqUj% z$(8nIu?Mk2CPbk@9(Vpf`#W}e;XR%Z=C(Wxe*QUUFB)HU#Xak9r%tq;k0Za&Mi zS{1oy=}~|E=R^H%V|>W0q14sZK4)G@o8B`~gMFfG7GrLIwzxn`WZ;e<>&56S6sZ|* zqP4d>)zH&8u^Z4WolE_43m+uDxnp3?55h)L9l1>ZB2trFb~y*tI##%{^k=g$OPwfw zOto4Ri}KONoV-Mwhkb(><*;NjNaw-JrjGVV)5+Xy&j>4LttE-pc22(9!G6Q$vu30 zT?hqrsqqrz=rYW5dRlwBl*@>ssU=_>2uOM$d*bo~m#)}?fiaH4=E>zFZ#HX}U87%f z-a~i%Vwcq({vaeeXMXwbb^v#@;X#}P9FB9=gpzE+7rYz{22ba4KT3?p2KA4 zakp#7Z!-RyoxGeWy!UWLj7KFQak)hb@?4v2{xz@FgS7iV!d75}PZECITk_e?A@oL1 zjkVw+{5LP%WUK$ye0cl?YTC!Bqv$#zii3%*=~t7u7R^8VP^F;;dQW0J(t$F`aN?bdVdVC~KwC*UF@&!5&_yuJ93 zV^92K$Fp>Gj#J_dCU%t;<%~;Il_025%CtX^zp-KA&1RseJK@V3!#zt^EK41`=gzyR zG1yT`Z$mxR2u57SbHa&knPQL&XVBXmHp1)gE_%$;Cub>YqH@7?!=hnxMs;_Op;n~#zmix(Z}w(dH0?t z-VM36+=+MV)%}d_RKxKLjB$jQ=h47(&zlE5nJJ zDalPa&$ahun-6S!w^98tTpeZZvI@`hBw!FNn+gTZhgXpxllGA9&);YA!tzJV;N7Cn z+F37D_wDrUHhq}|9`Y52&l)8nql1b{L`K>wGLixDXi@eE!jsM2Yjh+at-J6+s)sni z3?D>#sTnBj3K7OH0oaU=0QSL!tYT|{TBxKHyq7zNBhl)|ptZ@aAVH+uQ2lXa=RGmd zd}rzEm)JcYx!OfQ*3!MGAN$#yWvlnTK~WByQ&J}ti4O4H28MT&phy|DD0U~r^X$eN zv{TL&=VfgcZ(w|_uyt$U95uSrrS8Gh69@L9IpS*}1@OhO_Z@rYpUxcf6SfjLe%yU@ zZ=kBkpY^GWci#Q;qz?=ZBt^)DAcS76XF&Ihxr~(I-S=qP+B6`@(%2Bs?1f9d_+n{1< z47A(LP+?(lBlVlQt{-V;a*A+oFAl6G!Kq_WjjV0rpIox&`F}OCcC%~1mUu7L zwC!d?7scOGzgrtZnDep^Q6PpW<)af6Y{?2e0ei>~0&t$Ip*p7-vq+_7`^ovbW*8zl z?;9kp$QUA)Ah6mh6%)6>!-VnnIm<6Sy64t^@I)~$;rU|Tf%dOw&lpwM{^u{f;86oB zHMf0Q#t4eX(uU^af_4WNH8{Z~YSx}HaFDGZ81C%fQL-{z^?0x32zVKsEVS;`yh(CRXqJ%`4k}5DsA2j!r+aHz>8Ly1dueu<-Ou^dI-A{gj zsZLO;EmUtFjqO)GMQv&HSjqV9Da&rlp7MvB7BNIOIoi{>5A`DXDMe`4AW$_TEC ztd7lpuVw5-OSV?0TB2I8fjHY*zHQP7U1KB*z#huhqfk1yxvaD=U&ogj)R`w~u*e|P zvB2m!s){`LpgsXH(re^%7~|y^a4Q5ej2d=15Mhipns2@1&c!dk`y}%T4(AARI;E$NROCWp$d8UrGMiCNi5$jTw4aU__YrI)A@V7`{)z%Zeg0)jv3+q z$KHDY#!)2e<15+ZbR5BOWH4Z|HYorH_QNm-+Nri_}6vHIbyaX|!2I{?PoM9foj4`}>&2O0^Ro{oYd&qZjx`hZ@ zCJMU{E7CB^(OyQWvTJY`(WBMD@j8j$8p$qq_C0Ru&c8}jbN*E+G=B6YHc?Rs2|=hQ zg)>k(@KJuYzNN8YATBn^zc9+siAgBDc(PrAFJ>^9n=0_(VoKPfC##GoXGq>Cs}Z^o z4Ih9JS(BK4L+Cc~E2q=Qzzlj@{RG89R=&91ktbcU?#$snAx#N7y;kp0H;&Z%fS^~Lb^jBC*W2FZ716W{3~uth*~5QIe75b@)*PoKsf~oNVg*>Ne*+TB=AX6Pn*#WHc$fj_qUz z<22&RfvDjtt^^2aKo;T^w_M>>5^)=aFCd8`{&*7g7L~;{CEJ;6`wE*{+Eeg3$pKOS z+D7~5keBY?lJZ+dV5DgPDLH;K+y2dL>o<_3m_d7!88jfipd>U@BMBJis`6mOu z+$A&AN1cT_qW;TsdYoC`j(un0F=lhc0!c9uE=g zIOYDb^M{f)v0^+%vdSXX8Wd{e^dR+9qpZhGtLi6At2HJ_Rb>>B(x)q%6-7`fs5^Hl;M~Onp^gi(T48rHTRJ7OO0p55t^{a})y-1l=T@0H76ZNgd># zk-Ybo)bZ32)~&p^N{+3OZ@+x4QxE-X>GW|*WuC2$0+u1^U#}f0Eyao`!*yRGY=2Rw zEShM7AE+feH)9HKV$++iRvv%VpB`OD-JXGPj5Fe+SBdi|@&*5Czu*q@vw!Y9Uf#C$@h#T4w4Wlh z2p_#PSsaNi{@WeO}rrR6aJ==@}0Et7*BB4Rpdx!cR0!$p-)hI zdkcqB^$8#IBJ)?9H)iQJ9C%{<5>o>ogT62HJX3jbB)NQp!R=@4d*?MiPN#NhfC24{ zLpW4MK|YwtP$bZAST0#*b7+7*eyv1VWl%qaN@6*)DfP(m{-F#%DjUOHFB=d5!2nPN z{)J1B3aybl8|SHbo4A76owE(|c=8uF;rwI-6so9BvK*zxwsV&V>qb;fwKAX@#(y*4 zK7DR-#gV)-g4EAsZs_BCMCm2J`zq=^F*ICs~+wQ`7I6fJXt(*L#%NdqXfC* zD%I=`7Lj?{!@;6NjU6mX_8IGg+rg8U6j&d87V;B1sRi~ySjz+UG3ElAlO%%bAwo=` zN0D+QFvT*w2X__Y6&KN^_+?^@gaJUt(o@BG%>Y<{GcgbK0({hOjWQsZRz6KlMW1UmKBY+QnXO!jeW52sV-Y3jg5QOe2itHah zs{5UFw)^+T8h%J(_E(m&BJdS0sf2H_5|LN?=S8$jVUR>JqBH%TCk^*-d4@b~B}21& z<1<2hm$<;=HK($xfw8s*Bc{9pIuKpb2YC^!j(%e#foy?%_99V;g{sp=X#=Rj`-N0z zd^j-2Wo{jjrgcfzyc=t0ZOGw^z{ZnBk)g-DaMg_utay{VXWJ^`|DN8F%gm&g2C0fE zi?S#aGm+1%>L3*lmj@#|q9qeEX{EqOttg-N>qeQ8*cxtLcie#+wG95}P!?BSJ%;s? zqR8mnFV{V~{z=#0tyCJ%)LIqyeHai@GllGyBMd8Ofp`8@y~c&Jz?%?^6uG97>XPZD zL+Z-nEoK7M30v0O{@lvf{&3U9{Oa4VuBMLmtJf?~WJjFX^8{Pd_N&8zI-YVkg_5ny z3++p0CuV@^1$3f-LDlT8Xk69-1Ov{trdj~xeB|E;{8GGNf(43V&@hkR9{BjW)wVlz z($6dQ_wmmE8V^^mtY)WMRbX`z9huAwhZW1hl)YVvuGEaobaBBn(hGZQvQ9W=yZisP z_6Hl!RSRHa2#6mMPe5-BNj_S8Ms6HIVDhTw(G}&5DZ9%9T*=*4$DzLPm;ty)p z<`R^qLFGQmM&JV!6#O6Y5TNG+(WJOHB`TNTY8N93+oobnMr^j}L{sW*D7L;m{D)o$ z4+l7ehF#j3YHMt7jYez5QTWs3*vr(oDrRMK*)9{WCx01~^M&Z{Z}y9$&;Cs2=26sl2og3?@d@lRi=b)h!H!LMo(Xael$GK%7JR5Tr= zM77$Timef~PaCD!z(nj;z}R`#t#hEnHJYM1e(X9;DvcM+73{Q{-0!Wgetvz8b!X_r zrrgu{l}&B{lT0^f(lgA?3_4Ndu-nDv0iP00Ic2C`Ocy3rekJ~`f{$p-(v`0*J79B5 zePWXL%8TO2)MHlv<+{4TnRee`B@#HGS`SStz`rudCEq)_z`rA%;NJ=Y&I+#&()2dm z=iu8vIrx2s@C-Cfz1a`2mJ8N@;5 z;NzXy@=Uk$gB#%4t>1J5Pme6pP!79bpPGc$}K%v^O0K~QI`*22~c29ZzMHR7X9)lO9l zzLB73gso?HRZ#~mv6s<54RVWIL?CkqkP~)45ahG6DFNhc5kSr=26EQOcv4A@l+p|# zwv8n0SCK|nnieNvF1M%%EAhkvP($_n!ulRq*4ZRQ-a8Q_qFfR9oui3r^#x)rR5#ct zMY0S{22~6e6JnH3@kGXGbkvWJF2SoOFgH%NC+3>y!R>{2{K#&>T4|IH6Mg+~J2}W2 zg?x%eE4y>hljUq1SW9oe)gbgqaU|7m`Hv5^{gnB|$47)2MqvDa>>5QUz8Tly=GC=2 zlSgdv(wdfTRAiyo(or5&dBcoT4l_;s|FA!uuwY*AImiE)y)j=)o&Du!&;RG^OCM31 z#t3x*Mep)9QPTK;>kD&f$hpWxldb6aBuYHVZ{R_t{&fDY%5Y%|wa&3fS&|*9!`iW9 z@#BR1va#v0#B&4Iq@f*~yC+`R-jk^+H^d*AMsg|%;ta(iC*mPI4i|X+BXz;<5%MUf zrQ;Biz=sG#V`2}6$kp!@4rn8Z#2u>c&D|#_n9rWo^Q^D8PbnyCRIy0*B|=VBk~@rbn5FZ$z5U z!V!#U;v|#BSVn0pT`JSY|2VS`S zpkkYOHAO#40^7z`cX(@g!oY3{&D$*Z+y{ z-W~b)!y4;siVPx&o#02FI+>>26R!9Ikib?l3eRD6E7UFyH(Ns}j`$tR$K=MHnhYga9AqXQG=@%Nk`v)PwY<4#VPdVRgiYThTZf+n|sG zUjPpSM&eXaNPELW{5ncn1tKt_#4O~k7_n;ez2@W|b5ie?tCfue#|pByjl65q6Bhos zx7ve))X{QKc*_AV1!Mqo7KymZGeXKq-_&tA#9UftQ|#%*VBoO`_c zjon)O1n98-wb*Ar1=0$jWUNZ?ZnmQx6$;_Kr;-FxJ0W< zBicb^G@cY$y1+>#l1O~90{(@|Dn~8KiM~L=dLCZPtJQYQe|GxwxXLcWw^sixeo--X z8q38UyH?%!u-W~*+2@S$IZvqyDqN#jy;?Jwb#3)@t;wV}FV3>n0PzRS{IN@pY&Neg%}EH8XnI=rR5A=LuWuIIJI z{f_+mjYnVgG;edRPs4;Xkw2)T{XU)jE*;+R)D4^eFXrt@&dY2eR9Qw@o)960LO$*k zoVyE`?6HO%;A`-a zg9yVDN&@w0$lo2$P>L_5K1_i>1Rqe*fhuQ-zlHNBX~u`NAV5mjsPEazie}8~cO7xY z4-0R8pCPB-b@MEv^{2g|XFdGHV4NoJ~g%5@T}0hoPq=cP&)B6JTu7>NZ*r zQCT1w%b}(gW-ir=Is-xzLJin}=ILeT!#C|TJr{x|C&j78%y^N@=pJ;z)!{^`#~ zY{9TQ*N~@3h8V>8C~P8J#?i!(&d$^vt1E$`TU}f?U+V(#TG5g)Q%oN+8nN`aJ+^x5 zD6Ur*@!D4W$~|8_wlYH{KB(wp@wK0s=VbqJj!a9qkAZXHxKPx0~?k zc8zL_BA^p(!c3>k#>8dS14?t;uq_g-nVwL0_rb5sAG|Mzm73KgIjl%M-&Yz$P<9A7 zY%ZN?YXs)JtNH$)wmjy|;%oO>OWk~mI_{v398p|X{mnjhDuZ6Yq$toMoQ%CL(IdE*UR3oZ)PO{_5$1J& zNZ<3)F*8be3VEOKkr$L#a$fF@A3lC!>A_9vM2$KMvK0CyoC|@4K!tpZMuq+{IyI-g zyDL_bPPL@FTM$Gv(R38wP#>Ql^`K|q%!Rc(m43?$+^C+;M;>k1k>92`a(3mhS06k7 z=*RuVzlk1t4eLx=?viR_tc9LX+N8HULAY&%4n}!pf3#o7OFu{pyfPlcS0S5JQBEp)B8eA?)fw&AqSdl_GK=Qj1imcbI34PV=7^4I6Hp# zQ&l_MebClEMMOx?LOi#P)b}pg1*pGe^n{kAn-H?d6IR_Cb3r<-uO&~{=O84SF5z)2 zo>q0_*)58k^Yu3O%zAN)R~UsdSY1K9gL$t|UcDH`Sl8TgYE&^7MVAttnGSeWpeMuF zqfdE=HqqGG-jNte|IjCdcNTs-d*tU=>~t0zWXwoBWA^=Nzr+P+U%t&rUmQ5rP}dBy zU!u_dbDByj)Pt_@QYx3l*ZlnW?LQdKnWIPAV}O>Ij{!$3(y5MAI@>kJgnH5-3&I9* z+uG;NCPjcAxd>?zVuQ>a#c=f*7y#rk7mAOK@4_a87 zx}#feEuZzY)i&%^eyBRy&z^tGA>DsoUN&bFA2$HC2JixGL%Eb&4i(VuOmJrH@Y1Kj~fMsIhsu6OvqCFZ3-wecFAaCgpsWpGqDU% z?~+X0ES#T)dK6W2uKc+3pd;t8>A>X6lwy;}b!VS`**`vh@Y_@UB=T#cEutK+GGY51 zarrG9oLizr7jv2Fr5}p2P}oIvCx`0{ix$UaZrN|2HWGQt_u7}aWPh)^lNUv9>i3W8 z4Tmj#jm^;!YQZ6%de7M#+tc0DKa-j%gSVgYm*&WQJ74)ZtJNuWZ~mLjq7BveK`Kg7 z(i=r~VFDjd)La?IB zQvy_s;^~>$fcsU#J1jL1y{+g1nMM({wi`jp8yfiXoz2$#@b4?uS(A;gGt?+E>c|J? zIJflM?T5|(lUTsiVy`{;K zd=TrtWrtgDzv#llpLBd5cfPOj zR4XTkH>r0y`bBO#d$0ej_ryi>*>B>Q6CnU7-V!WmY&RC1l%s|0q02Kp)4GOKO�Q zG|7xZB*k%xj>Ja}ef&R1Pv3Ugs4&@d+t-tFwGW<~6>JYxB6D7EUO330PeWDK#i!=zASX8Hs(n(xEHtob6&tO}daL085 zc1#Z?|1VO*o%LhosA=dxSe6068>i@y3G+3J57TJ8m>(L3c$W8Xk)<1JH7A#h-1Fp* z(qA!AGJEpwm)p{(u2Hq#TB~#U6elz8bI%e^Lk}`yys}4|!9bO(V_6X!lSOk}kuouL z=yUA3#Px%!5`vV{|0r$7S^Uj)D+@##x{m-x$?yBY1+Ku4fiM@kM7RT>GBC;6wHgXf zj`UKvwHwsTaamzPgC{HT-*9g|+k~&Fi8natrG%o$?Uf%~ci<79JbJfJbq0ItV|oI% zF&rCQge;t|v~{;OAXET%O*iu2RC8)wmthTrC0_z{C@?Rc2wPj!z;OrljC}2p8;s~= z1rXMh3{4VobCrIPwE!h*D&lvOv6v*G47$R}VI)8F;o=-Wa?}K+OaV;V%-qT2IS6@w}Klpiom7%jK>rv{NYpP>WGyX)-}e>wU?enkcid0(|Sa_{2uPxmiA`R%XNDd($B&Z*Wt z{pP}Fa57C9LMW99xJFKa* zy%lj9v?Dfv%RJ}J=0_gb<1c^VIg16X)xEj8ckX^<=VKduGX}meMgBeXYM_U$|$;;TI?*2NMfhYxCJb=OBrUQFv!w|UI1E!%97Y$#0ha1OV^fv)pyQ;Z7$Y=LL6eFfGyZ8{{Y@k6c&vMg^Z2oI#53Wxk}<4!j;mmJxj-egB`9R9t-vH(;_Q z4e3+8a!9Kc5ZhSmPI4=T%!H*Ayd;?&wrvSn;whMd1!|LvO!QC%Iu5PI4ocB=AuppA*0ZvEZOK`dZ!k zS5R9@QX6h01_?q!yMPLF#gm`!wy<*T2`s^aJUK;?r*dnT9=g-C&+k>7&ZZWM#DzCo zqLe$@fxxD*LoA=>=5mHjar(mKB#^A}MV-lG)(K@VmF>zw+ZOdD$p41opp@{3MmH5e z*R-2-8P>A#z1q7f$96aK%kLJz#ET36^ot1*+KGqW-+YE$?I z8&9`(h$5_A*xuthp>2?KkBZ+66Nn@r#c8>BAk!;&5r0D$U!Ee3 zzOrD%Yq6N*;}V6B<-gSHSmUD#4zRp%+ey#ty3zLkEK}JR_PqYL=y=kHsmn&^7%H)4 z!ges@uBxYE0Q{{ZmZ3;pqb~Ygr!25pT~y*zInnEj1W&2g&QnYu@iOLjs480a;0Cn|IoC1|0sKGHgrv*urwwkB{ z)hWFe6%)Fe%B5ngRbhji!$px7H#%^))Zyz4yH+cgr{if_ex}?WV&%ZtopALb2;CAT z11n^C(+n$)45WPkxQ?!oC<29rccI&ZJk5uGcF9{$Tyu)mPCW?m-Y>Fv`3LW=k@-{X z7A58X`&f+1!qV^svUA+tNLo2^t`E)TIsgG3N)S4HgZN(jf&1Z(n#$qg61Pu5OWZ-Jo{M+bYQ0T%zV`&~BWy2t zK^`L-RuI)GV~iMQ)KN`FwqLhBBjVL)xrc$8N$d!A&cJ6*O_a3Khbk ztLG~@Bc~n<>rKx`>0}SRxYhygF|Ye3C_R7iM(cjrulupl!+g7r2&>O|CWZK{Evy%6 zMDt37qkn6{R-(qY5`ArHIL0^0azQXiSS|21a})@xkIa&h-Vji4S{lBxeDs4envSTL zs^RmDVhDqfyHjq zi@de?+QHwKfAu}*ve^s>?=?A>6rwzzc(p_&=mH!v3Q$5i)rBB&T}w8dk(>c27fZ~N z_=GhG_d4(P%z3J;oSznyJ$%0sA= zYNu7VrCYjl*;yI1af!8|>~EWGe)%IIs0TxH8@z^!+5_!Pxhph5Hmdrk5oc~s?)($fVTzky$*L0gj=JR6JbXk!@u>jC;s%FFG zhyra@^38Qq+SJ-rretp%pHIB(p&i~|cK#PUvQ2_Uw$Vl}?{#IzZG+W$o1}=MWJXVL zoeSjg)A%d`5yYP(S{gNfqd_m$u6%}{AMC|?JDz_1n4Q=9V5J(t2z3<6`?SWI$4e(& zIah;XQVW-hVPerI6@M*}X=Gs>8_!K-qZ&}w$%s{$|13Xz+1lv|Ycp1f3jnOn)2QYq z=)m+=6j`?Xs&xjgJ^$my>X+_y{goLp#66HQ4JUmsUDBx**dkVp-h#1+EJ(2_HI$t% zMjtADp(|QEPs{Cafs5VY&5%hM$T?8tyiB>1HF+~hf7eALj*_DIjgh1-zXo05j1M?Z z8>LC+dOm^exQknHiq7yQ#&}|~j?PER7w`Ac`#&FYDjPR0q6pY(ikI4YJKlnT2DZ=L z*5bWoXA4oPl!@#CEeT=}PYQ{L$J#>{7#H{!cxLbds|Rc7(C;Y}*OD3I)pmi$@a%9} zdVJ|xdU$4x1a&{6+HS+d(%YIo`EB^DYsE`YQ5HW6I&DOAK2Rdt5RBkN_H6TN&B z`-BY*FNT1S2z4CV^+$GNuv?swUH7_R`_;*~ZXtFALkv~?7eAH{XDh^S;DkX9paW7$ z32s9#Ay@#agYNp!_kX!-(#7kswimP{pX{*qCd2l;vT>Z!1D$ewj0pS&`I(SFMFm;R z_9lst&5>XNg@`gOixNbrOpb!;wl|a z@kfwlfDu|g!X5B^N}W!P44?r~agt#*X0&rwkRS z4mKh!Zxi<6|6(x;|J*ubi27m`lxx!pJPv8P;zKo|L=lLhxRSRZ1(Poyy<}Vz`DXF) z#z$wgZpEcJojgrCA`0Lkwkg83bvU6B^BZa`qCZl8V-Xj4Y>D8N4f8<}*hSK;#*mEr zp-+6R*OMES5GR+7K)qDnc;?`_u@|4dpBYF{9IGhuV|qyOfV#W?F;S_LHUX0hDA=dy zG6U>Lj;y0!kYm8^F5cAL(qdAtahCRuev0DFv3{ZAAQooq;{wn6QMyH-v0vXTw{Ehb zerzr}u6jyC3q&RLdlEyXS_ak|BFZl>|`vt3XCZnj z%z8P%#87;Ts#6nSsg%k{Du!K7-_oUY-ynz#J-R$69_^+}q~CZUGOXk9(a#zFlbbYQ z@6-PD_+Nb@4)hto6xeG~hzG)*5ELtMW)M+J2L#S@SXtXPXMzlm!c7fhC{uj|nWy}9 zIO2m^l_GcwfrDtC1NH&rg8I^l`rxpi6GvqusMO->+#AEaYPx%s{k68eI4IT}iy}WS zzr5z=+g{vmxLWtY>L|Rweh^=@lmZY)qeOjl zy}Ps7Qk((LbaGm)x)z!?5^D&dL|ouyjqv6LRpdl`NBZ1DnO!S0IMg5YT6>9cUOFNM zhtffkQ?+K>y1O#X&aZMAbkk{+igR>`)SP3bW~-4vU_|^hCT0-VQKMeTf_{71r^0uw1C_j7K-Ngf4i@G*AWLj&lVVuijO>sReiMg>6(l7dZVe|SKSAzN4V9q zXk*|$fR2sWAt3-s!7Uk*MnwftD6AV(pR)c6GFV@IEce1o2knz$HHO!P-_#!ATE}M3 zt{e8+uC0DCAuuO-DtJ2gm#so#Q#k=-sEFZ9*$FR~9_F4#M^(?h>$^%R4Aq$64lttA2|@!%08)1FQGVt-D%#{dWL@jTze0DYF*jUXyT!#PZ2S~2SCH1( zFS7Qc>+d}As&%g8&OdBmshZtMN~;r7;VmQOZ@GoSY@ONC#HhBmWLZ;5Q$?aQL&X~7 zsivl;SYtec;2LF-&91`SoOR*qx0OG!PeMXI9R;>oh-gg(@Ky zg(;Eab5hp?(A z8Bukii$5dwkwi^X?KvZ!@&!JaX?vN)+Fh@owr$bM130|uVrKaTdOG=wm^9V!AWchSe#J^E@%cyW^ap5pSqGu7T(`o;dO8bWa78-TW4vWHc0F-AK5{9P-#k7L#fa1vd3pYLG z^a1Z~vXhZYNFX5e#o+Od$`Oh>3s(&jE=F88Cf^y2I*2q(=R!Qv)P@ z>!Ke1WO3+;S@W*%H~aeLJ-=^ebBY-QAN`_Y!}_Z9`G=04GFp*tjk<*Dx(Q)XD2wkOXeH5W&65*FZz~2`yH?&Vy+*;xjBZ!b)%lFN5b8^gUn3N^@~!i;$Poj+g$g3FQ34Sj{P~_CvQCT#?PD2d3)cp z6oK*cEov!%)s>^8V0Wf1ov9G6R%EDJ4RS;GUNo!)3NBc6O1SXt#kxJR+f}kiDe9Un z3Qvef1hMZ42D_Ur0;m-4z<*O!*d4?s{QfG?E}3P{GYq{$l>o%>*q{`VTj3}vfkV0= zM`tN2bCaVJ@9of<$~vrX{jN@$qJYXF>b>M0bIMm0b@i>SqOwn9fY_NT6(l3zBZnR} zh0N!vA~QvO#KknXP8)}>GAbrh(4WSB$#L`V$Q-?FQ#MGw9FQrSkG!{vBAXoh_vWJy zEMJ%5U5>p)8M1|!)s4dCje3Y82YcSY{!=D@xyY)Y5|p`I9NDb?tM9*_|Ms2xsF5A1 zj;N;9na}z@9my$ zh`)YBQk`(jXko7;2oWkXz08Y$i4Fhqfj@lDg9=J$DT-{l@^4p9s>$u`STr&8Ty2AoW3!?ohWs!4wfDx9kD%w||4y;+~1u;7~g{*mUL6ytrXj=X(~BLf?E zz3agtqb}vnEG}A|60Rtgsf+@)cd4tWbYT0lP^8Wqmfht`?xIQ3SH4mzPlyqz$y$k{ zrLx=ACPWqH)>r&(lxz}&3}VTBDc>ez?y~6c)$cxi9=C3auwRVlnJ0MQl}CJkL+0_v z*=K9pF`$4kIkYNLMsk5Z+jtB<+jv7oDqYdkL>^oID4WVt-#PNxK6Boa18=+U)uqhl zSv}?9@sWpF9ND??g|gVbyI=6KI^`NDHz^2Ohu;Mz$B0hFj_>Howzrjz6Nd&sYxGE* z-hyp*-uSGAN6k30(NMEv?-DM~CU$aww4v;xQc-*zQU)qHw{9XAd&|`ycdTFkLpATz zAoaW`vggWyFTAr>?k4UllQOVVC2u=psX?UpvScfmveE(1LW2|l^Y+{;e=cHrH+@bmBI2dg8K>t63& zbkV&hJ#+PF{nN$sy&Ec-Mq|kqD^@5*A)p!cfM!G!vT7f}Is{as)cpLyjrTsH-(R2Q zv3R!-kEJLQA2?{sOV%%bXdAWL?1d>*+&e(nf=6O-p_X!(p}Y$1WU1n3x%z^gdxTN? zLe%lOUe+pY6AR(bNl->?8mca+3AX_?$aON{;}i3sap}2on?jjT`QZQ2#DM(_l)xAy7rbGOpjRx8?49^|+-qyb1_ktlF4R-ST8M^lY_Gc} zgBC$t-gw~pcVvR&X9euQ-pRG=ub|G>*HI%?vjudJG=MQvubm{lFS?_K`M zY=8bq0U0NSc@lWSm~>gaW(^ z6*8bM5nt}x^Wdyqa@VrlvK(LPrER%2bjgB?PP?zCUsf|6q6rDuy4Lt5A>Y;6-cr_( z?P^WsW?(qf@HE>s27g4$Iy0^9v(PrNy$2OeOQ^6ViRKUN_SG^Rb-1OEQ|*SUDB$F|smAG^JJe?HhVG<;#xg~LzY=lx;o(%$pF z-+MHlHXQ}z-R6hO(H_WK;>g5vTj>;klnl}vc6Z-jpC1}*&W!56bhEFY?s;p3o>GJ8 zOP3o4SC>0CjI6w^Prq>J8)v@q5>o^>Z1qyas72TOR86h#j1zxQ!3-q~`AZTft9i7=(5aed6Ba41U>3wJ2 zHtv^uk3Wa$C)l%)y7JrU{~54PPuAyIP>xx8q(+@^!cR25h0s{+Z>SoJbuAEDrwPUS zQx%oBfdj4NZNM|A)Gfzc6^-C-!X$QXvR_q(Ni>P61W0~7oC@Q~gF!_q+!!yS68e6m zNtGk1JLfF)^UhTW_ft12NaDvxz^l#B9mJ(&ob2W(Fi9he|kQ}`*3 zjUFH7)n8m*6HN)f6pKZ5wC6XyFuLHtc@sY1CXKczArG`{fv0N zAem9w4vj%UgHZI>-g)TlTMeyXNNFS}f?X78eDC1z-+%b_%zHY4CS_^}JNmurtG(ez zI`1cTm0x8Qeqa!$g^wvmnov5^m}!J@s-EbxOWm=IZjmHxKqXeJAGZ^J50wiK^c_x# z4R00EEmP_rdUO%bGm;ZbZpBV^F%`3Q{K$e}dvd!`NLmZtV}KBotWB#;UEgj~{_N#n zO;@M*O3LR!WPXCsA~kfPtYCth5%YvD7pL}3DYR^?Z=aEAYp#momE{*`v`+7`5gY0Q$Oj`w+ZGL}{`YB@-NJo6os3eJ(Jeq}vQwH6ts@$QlbcAg4<+0@ zUDl@gqbM4mlq<^7AVUa(Phbq8N%^Gw1{8Rf^(t|JhjNT)COCBw72IM9zQ(#p8SJAm z?TwYFd-~W_XV<((e!k$k zzy9iG2*2AhGRk+Z)BQClT@rw-*mK=_=)^*u^_PhGGf%K@Uc0;2-*B_@uFmYN5d$#X zr5Yb3eH3AP(0YRGwdR_8Bk(>4ngQw=GC_lYG|{0U`y3Z|_c^>FK^e+|N@0^DdA~c8 zbOd>)`dK|p43C;qq;*3 z=559uv)i|?eaX`?!=r}qbQDL9Sh(%t*Jo^Z*BU;$Q@VwgfSlTfRIsBlG!RN>O!NTj zZt3E%C{(I2n))qK*isPawCGMRd6AsFk5J>X(Nv-pPh~Dq-`ZSS*-|yGxyM9{F1gVYsctlR!n5H+E*XN)5ER(|ig5&2 z9BQtDzy$UHJ)zp#GM#v{03gyY$A2>T$6f2!QtqUP*Yl)CYt=tJYUl&ewht!%c#Mx4 z3sr_mPh7QLmMC-!{8xCqK86x3dDS6Y;9-+Q9eNF+AVpfM9Q*1M(LzJzb^C|p>T}k3 zEGfO4XsG5=h~tJ&ArAJ;99=)}r}K}!`ptLL>UuOH>C@MG)fM6SEz{Oi=Zs8eG+NV~ z0@bymz)ebOM`h*1=9V>djB9Jd_968SdQL#qE3w6*h!t3>Qe7s~7>zn~C%R|wQjnWo z$f{_W5LS*mb)rgqv)Q!cf|GYV=inGK3+A$3Dldv0GjPQX!DYJG34uZai1lRHtzaPqG=>5I3?7|< zh#h4{oCpB?POu9^lhC{pKwC<%t%AZuE=$xxatHUt`3%DQxQL0xN3GPvGAO<;C>)~* zwW(mkx%Z4WkKtYLw+Js!siP@}-PZvX=4)$RMEy z-e|cCsCkv3a0IQKRZ*bt2oe|O3EcLH4sNTJtg%uS##4$pPLNlgYVY79eWDK_*8~RP zN|I8ijM53*RtqwX`xz40(9u>40fvlxs0t4_?G&R7y}SsY=tmoE%oL@LHesD|?6V)g zKeeKKxjJJ@7*)7lt81w}>6%QMFF4P1eZE7<42|ORZ&6&}*`ncWFUVM`inXIK(hze| z+hIF?eZdu{u#CAPaFR}aZ(O=&_Y1Z=N;649#;kIcFqUfRNzKW@1Ch(3yJwJ6cy;;0 zJuew>iC#E{%sF_;=&fE0x z(>qKXa`(18g~4=o#=zbGc;@lfopF<93T+Ws)-gFZqh?ID(?GFXk*3$0>Y(5-WjBiM zt!RrztyJ?V7a}bU4j{S)_i-dfN;yL>>XS6$0oZBOxwV`gM$KBw=~46{K{g@o_3E&W zTQ0eBPCLKvMm*8#XwUbV@7>kC?J0LH<)v}%D^X@ryRVeQCYuj?NvV9wnF z59L8c`ny87#2}F4r+l&B88@%jSjn>(lz>wdIcwwRE}gSW@vRfprS>dB?DeigG;1GX zHuFusXV(8mTse7KL@T(a&T->2LnLkj6G4;?^~>x2(a^ceJIw(1#0-e2ie5k|&hL79 z`JXO7cJuv}Ix<+%zs!a$xQr@FqjhD8)*&EjGaZ?frJDlgV7FoC4G@~17M&R;MrN+M zEudn@8YGM#`=;~^csIR`5^6kPVI$f?*^OgFUc)Tad49HA3&A68EdI*xn58k7cy)lZrg!`eGrQ%L>ljG|D4m>RQ%x{L#lFsCJR$;-q3y50O6)@Mb8 zkJeIoJ_Mb&M}66QTkSY(^-FFqRljtuDA8BYym*Y?(k9W332kW2F>jS~OP~mQ(|B0+ zb1y&k;5h@Eb{lkBpDnKcU&AFF?Aw7?@Yq`n@Pf7F0eG>YwaNfqr6|&j|3oWc@Gv2C z(jEt%0(ha}P!PbYM*8%6B=~}MMA>i^Vevt{8l4a?KsFNeD+${`&KiYR72<=z8!m`f z1>ERvh*u3kywvZ(XSKMFU{B)TmSnbHzh}R?bA6f=xo7$iT!#vyOzDCGYI+y}OZL#p zqA>t)@;ib7sc|DJ3^-f@eK_jD8U@MDHFJX|P!KgknI(?!d18dupFq+TUpfV(6oPm` zcf=eC&qjO_sG`d4ABOxa_l3+^VEDPzHC>agd-0+rqjJ7wEz~dc{}C?bGuYe^D{e)i z3rP7|k@za1DI6A5q*@8lG7`f~5mg8865op1gqrG5yaO=S4yi3FGf}uMlFU-@s?ReS=!`ikK>g5kwl|b8D+@3fD++PX7^fMOyWh68;-rO z_K*|re(p>kkrxnCwzUj$6NhxvWWyBZtltk1j=vlc!j_^VRvlYXeQk7n2}m@Ti@Zu~ z0(2U1gzpSAN8=R4Qc<kA@zZDm4(>}E_ z1FQ>OQFN5XuIPrWQa5p(GvejG2z!t$E{ZJJ_?_|f&5wUvtVr6H#YC^ch5n^BSFh+4 zBi8h-Ahm*7d1%iHh^zb>E-vtBxP2F;+$Rd7_Gz_opERu<(mWj`1SGm-hXxX~+R@k` z)7It6=fEtCP#!Lu$>JN~=2J`-GbT7xqRYNX3Dv_BVKQJU>btwEz{!RX$r{NyID;>V zx8WNS48u$+3rk;$uLM`O`(4lt#FT5O*{v}WT)B$wi-Wk6(;H>PhMHyXd~#38dC%^~ zngJhK@`oL5ws~v+k@HtBtH1FRpOOwIc40kJm_smEx9Cpm$#!yA4gUn3H4I7?RxLW} zD;Et?3beMA?m#eFuMOpI)*#o)hF}r^ zi_?r4K%rrvv^Hp4hk<6As|eFWpMo4`H?MiZXE)t-^w~Vp;ONX9i4&{eDEZ=odLLa2 zb17h$PU8H%8=rZ?Ts{D^qcV>y6B`H|Aj{FJb(m|@%CbhESvAno=Zr94@J7KOt}&|&(Usdo67?yg#x-BlH`k~peg>Z^@>{?rb`m+pH8r!z)W zCac8*SX2~69;@GVr@v3Vh$oj^GUu?n zhh5*NngC+V@fC0O7B59{tbs|og$1r{D1s*FIF$1FBC$YX}2 zIVX;VJZAA8;W0y75DUo*&oBORLf4s8mCtMj6hTxLm5z!^+h>OFlQXCTb&s&Z^t>X} zXVxZtX1I~Klkk}(?K_jtEP+N5KA#!!I7>JiP$1>c-8AUWE(wx=MUiJ0&R@H1_Ogu{ zeN2aZUs6BSrOXQEi769ijwdA+V??O7YBoBUpgb_aM)a)ltVN42-FDw?Com`SY!oYv zsVMS7|5vwLe&xC!avq}79u}48Xc_Y1R#f@s(gsmFLrh{cChKTS>LjRVG%5-_O9abl z?_Rd-%9Sr#Fd8pH#ooe;ul(%ZJMTYi%du+u9#=h9i&^8T$Z``sMu`Fbs}G`YnUpZ$lU*{+2| zaE_*HayFhA-qJc@8iKYZnYLMGQ?>;wR4NacB)Iy9Ilp@HyA4nNWyO}8F&%lmbo}^! zkvA4*R{LR5{LPe_8u#N-LYT-%i@=iYu%wC+jSgwZ!SPvzB8PLPLjZ`}y{=S4OQ1vL z$CZn!W*u_H13bixXKi?hZ>+4@Y2y=SAJeKCpez*}kQ%7KS;#yrr-InIu2gGB4T_YY zVj3kk(Tn+18aNUKc&luvI;y|#fAQ9LkG|)s%XqLsb@$#__|#(ya>GC6bWZ1N7FO3- za0;hI`MZ~2%8jYh7=j9Cv-}bvQ0YClg_rbaB2N(hOfF5XuCbKsX9yPtd5Rd*?B<^Z|? zIdD^gUUEqILlTNbT15guMro56srsfu779c+D`vrZtC&&{Q=OfuInl%rI@D!mqFZw& zmqSqpT`J_8xlgYA>f6YfoV&$**UNBtbMvk)iY#4H{`sdLo;hTI+Eeycv2=TlH`lo{ ze(!G5JlFt@n^Z=CNZA=_5i0)Ta{7GcwbA zCc?6hBXzeiW9B+iNIP#VQ%8t16c&@;wVu62#TGyR@o*+|uO#pj`ui&vuXu9mc87E3 zyiMpTb3V{?kC_xOl%lF2(;Yn6X}Xu9%oJ+z>344Ze)UhiQ})VaoqyByDfMp77nqz&A`#2mWeN+2;%w2;gn*WM33DBv#3f9rN-!#;wy|(Tl#9}V_BWfm1myjcJVR&7T z$(dfa7y^CB!N6~*Zxs;)u5e;?Xd-R9&2gnbBO?-`P6=wvgPhM9+iCS8;eVH0a z8Q@X`nab<4HAaiK44vb^aJd*8Ig7otm(aOnjaZ8Z$4)>;5ak4O`FBU{KlYW8S1_Rj zH*)x5(Wa%(&e&p&8bwQk)lue##Cy@|3eND(EVa5SakaRjj8VMO_&siVV5gJ*(!m)% zY+VN({iMCJe$G43C7O3{R;O$VQ$nV%^&VomZdi6{vn|!uo(uLUlx^_I_;W{o|2Ljf z9=U&{-<>n6v~|VmFMj76sn`p$>;WF+^AM0~Dts$~5Of80xt+S$4%H$iYx}kl5Wtp* zMjb^pT%|b_>Eo)Dsdq-iBx;R9j!llcAhXI zdh+metN#Y-o9Da3GM|-+?XlhOwDg;r(rN}RD*47V5R`Tp| zwps9)e!gU=W?w_=Ir>(khN+!6yRoDvP8AsIZElNk~_p}Q$6+M2(6|{W>NTT+Zs`C zhzv6`*U}znKwNk9MRzYTcd26vxJ8X_p*r%x9_@ykY+P4)!Uwl;vq6_{X^e_o_~Z6c zpOS*Xk;VlB&OLt=P)0j0X)mE<860qPL=XvAmJDfZv<)P&0m7lZL^(-LQA)*d{^>gfI3p8Ab99CQAJ)tTLR<)}?g19p7|B9P6JiL!#1PkfQygJl@fQ-u!UhT0s)x>C3 zCU%DeWw9wpsm8MaB)W%G#2XkKL$Ko4lsAmuTi^;pAsg{-g?FaN0jEykgv=7cNdW2N z0#b_4K7YSRE76+6Zqz*0dBE@8G3U8H&qOf)*nGu|5$ksRbzoYNoXxsPx9^jnNupIz zA#&!h9ph*GW5Bl4nCY>cQ6upkY%1NN>hH_`y5gw!d;C=D@TqBC%`P`S8+FpzD?z3z z5e)UMoX7>H-O$A7Xm=RxcCR|wVx^5}lA+@hz0^y!LWt@*K%9h|tb;OZ&}B}BB}v?$ z9&P`~MQkV&GSQbF9n9didFk-gr=9iAk;C;2F4)Sq3tmz4y6$XCqtIyJo#cWbCZf~v zp`Wc;JZ-&~na{CK%cNve(6%cEoZi$P*=)LIAceTagsKSd7j%(?AJmU^={2msn+K_m z_E@(+?%(fr?6B_v3w&c0ev2VkMoryw%T9!~l_X=DM8vpGp%6-b={I3uUjE7|qM~)F zx7vFZM9|q+w#4t>?bg?LY1mHYx3*t*;5U;FT5#jLX)fU6RDGp^O7E+&4D?$Y00k%T zpNnEr#X#QF@2O~U@{K+QD)*10O@054> zWOgt^*lo3|9)7!Q+K>NGQ*7@LFa$QYLXk5SBT~6$!43#EBaB1fXgcROQrUvb|B-A2 zAZTVcy0Nw3XZdE+RsWBm=UClVsv6j8L?;P|1irj?-jYAPeD$BNXM#IJz1wbq1h;$g zhBK$$_J>zbQCHXmN3)>iiHuB+_tuM*bUU%4F|yvMmyU^6&1h&9;9I%(;IhNMczd?h z8X;Kk-lO~Z!|%9!$(%91mw^?B`WV7Xso{BQS16P_nfTdUb5LaP?Yqvta;>|EUCBH+ z2#Hu6iQj%h>+(&``)j*j!74OE()Q&z2ukw?POj}U6()yr=IXF*U+vxYr0fM50}41X zS>x65W#Nh(M@rtKyjv>)5hHdvs0=iYs8`-1jpgdr=0!du@@l2OsKVzj3hFl=pK!%@ zmn^$&;)ZJX*ju51AT)Lhk(Va|ZMD}zRk4p-&)oYaEqGVKfa5jwqwOp~vo{%UMWyAk9XUNMtOKUDml9z#-_?kK;Z*~Vy`3cB+&)s^tuj`n~&Vtu4f#sq8XrQK71 zsqWlo(`pSvBD*jMdJ(UshP91KMNd%2Tz&Xy^K*Cm=W54x-pR};C}2_?DZgr+eP8O> z^4kB2Tny@7+RI#w@=cx{_l&G8#=L`fG7i+5(rN3}%}n2n-O7j>`{ zLIokNFAtk?&`ztBJ<84N$jTm+4{Qc{zNATeJ$b;siJ^0}-UHRO?J1Rf=R-GE5 zj^P!U%9XB2h2U794|On&3E@v;Rvmi^RuvHvb~_?v4Ww9u`Ooshm#v+iur`~otO-u! zi3>UMycS1Bu6X{YJGZ%c;y&sZgRFT~Dw3}DW@!d3Ez=|tU~5;2&$-gh3=*w6AtWAO zu*N}${j}X7yl;aja^xnb-g4uHsc!$SCEy97EkQPcG{tB!1>S_5`+2$+o>kKSyNiY& zdle7oTn|g*xhRT^K6lGQl54N~`VKywMr;tRNhy7L%D5_+yuzy8tiob9YD^l2n$(4qIw&_vBe?WZ(UWYZXQYdkD~;MI`Z*OLyZH$0X7e^+3 z^X$79tT^zF3BFO2DUmBLoTr0hS_p?!6@dhh-Pk3;H_|?`eOBsx`gJI${N1|Zg*t|;Wmy%FJn7^J7du(+i-(5pF~#vCu@N*B z=2puKbg~DVQ&Wyx=UGt%p$-VR3_25^g_$U&J+Q}6xw@7P_w8Kenh1u(?awE$)0L9PQlps>0_KC2ph z&bO;W{h6_{5CsSqc${UVC5M^K8lNRfoq4nzn9b1=^iH2eIV^0@Z(Y7lG#0w+3*&*?&sZbN3^~ZkE{d4lFP?YjIZYjdeR6`tgwSa8n^^8% zj0!$O;c|<{a+xkuAmOk*)}K+o|Mn;3?&T2#?cL%?rhBJ{+IMK#Wr!Mqt>urMRhgSM zxnahvTy#>)II8hRt?*C++??5+>6}xZ240tns0Z}R+a!5Ms{7oB?q^+{bx%I>ZeTW& zdE}$_E_|=+-QCrgoh(go;Q;k6ue%538uB~hf5ZBkDlUu`0bbNE)qZqq?ot?`c4S8; zGlOeJN?C;8+i_u4QIkXwp_U)c9DUW^fBXA-%)-3_gy)=(JoiPBrqzD>HnYvE&p)D; z%Q5?4L2xeUBP7Z-B`bP?8r?PWBugrvl&a(ilAL1H6X1wRf7;i24^K$W2K zp?D1Yf&d+G_<$;<4`?iWK=eBRo2X720ZQNlvcDl-hEceEK=x^)3>^*m7xLMt#8z5q zihnRtBPpLC-chelw|C@{0;g;9N&5|y$noJ~#2Cwm$x+iFd|!BL0alsy^vUpVKhzi)Wig}g1i+>o~eAMI^1GgJTRu20s@`bM1^q>ds6m75;8EhN*y z1d#>esPI&648b%G!OzJWhM=|rNWdklm|8NBzUdnKA|Ec18gtNn`%doC@+loBD%(V( zT;T>maU<4a9{SlOZ#{9%DOQb_;4-q^=dLwy#*JS-$?B%s%(ahd;l*EXn?~gB^=zAyD#XS|`mI<)JoZr=eLS z0FSaKhOh`blfoqY*G-qtYns?^52h9GaMUw@}s*ry};fLz0zyED;L^x?>DTp!{}vQb^hsIfhX~i zS*yfLv|?_iv)x2I1~@O;ZPddQZX$n|!(fhc=!9wiX#8q}`E%9u+jC4NR7oC9I-11O zGM#NHYH%YfM-kIbRI6|6ta4Jpq7IJCOcT20(!b&}6rs&;{nO&&k!M&bb>oy9^yv(BC3ZqQ@Gs ztuy8>iw|n=IBh z%N0mA)Q`}72YX)5cw}J1NuOSI1-Jhkw(ImG_IG=a{y9D`bM3umXX4yT)G3=)klN0P;2LhhGMqCou_H-q*A|aT znS@fGNwrqzYNRBKQB@q4YPs$Xux7y1f+WPB-~RU=kH%hpmLq-UGVbFb!VyzoiU7pTNPWWI|+&9Eu;fYJA-bem)HC$kO4uu{M*I=*{ zJ0l*89vMDc*K6j==W93unqGNCmJ)Ax88jnihg&UMb^>t<6{y6cC z9Uj>3r}0c=-u=R3DUMv#U0rcQ>00OMd<x@wG(?H zm-`TWR=h{bV805%l|PzMpd!`MlbVyKRLS#iuD|!iSL|0CHukGl?6B9e`PB~%QM2dV zAlw*OA0V;fi~z)_IHSPyQ`vK<(tmue`ldTJd}L!@(EZf|HV$0St5>T$xcp5KI!heaVVluD|!HFRcRDLCaYbx#p!U`(3|a!Um(& z>^Vn*%+vzh9d^h)W+sg}sHGycxKIbY-Ce0swOO*5L#UF442S&80T+0g1GZiucgR!P z&!?tZDy?VFM{B7O-rI7o&pw`a z8M>E2H9m-eFWbbuSF3#S3@+l#vu)4rJ)0z+{?7-?uDDE{axqQ1WFLtNap_l!A&gCg*pOY>l`&Ht*?3F) zv~Dr(Xl!^(dqb*abo;bvna+R=j6Y-#xjWH)?F&q~!D`h*Rh2uvc}L}TzcSA!)j17{ zuTEiKcJbhab?Y=TSTYhclzx$?j!Ry>(Mj2j>vfZ~N>JF8X@iWZUVyNldgnuNhc)Icb4lPjs=kLYmg zFIA2k6_uEK>)9_=n(LzIZZshb36uj?<+u?+dhMsVO9#Gp&lil);k?$(Jq(inElZJLNxsb-C)7>4}OkqDN3O zayt#V3NdAL5uz{OxVr0>vkx54)s!M<@GGbzze!PK@rs9z-{pW$AD^Lrmp-(U69YrJ zP8(#@%l2|_ay>lXV3!;>_qCm`y>VGgopD)|BprPf|E%&6u$2TQmO?PXM1JPx;l~~Q z_GE686JZiiH?|J;M7@+;GVs}R-+gq1IyXoiEw5Toj|u6hz+%A^kHYnr%hYCa-7Q@} zwxWJkV;0V-uI#ML6X!JDc-_wDKft^$*l2n65o5c3YCdWz^GWGKjTYf#7bs69+QQ?L zbs_d&onyg&WsFyhNh56CApB;_EcC0LJ`++JDkukzkgPG5061uai2xzhihpOo&j0%0 z=}ZYvyq6Sg5_tWQ^yUkGthxAo-Na8}II1?X?!*gA<4U0ANd*vEUA~%6HdvllD>Nbx zG-`;s?t`nsdl+b~GtfpCbRXtbYtU#2#6DR-MxFjh*d=Po{AGCnsZ{T#S$DsZRWEqV zROmyf5~xB|=n&TfCl@zi!$~j1#_M*hGLj@kMnbYfaeLVmF6JNr}Y=2+hrD8R;5>O~EwfX3>bD!#Wz}KUPa=QUGJ4xk|)2vsKl~YaXeif;Xj+Qwl1jSztIrNdE`j5Gl z1E-VJ6ItE#3V!e3!36Qnao;Z7?(?laTUSLSoVsBzikDhc;ZINrm-wY&65pwk|4Oo8 z97Je>N^G_xK_%X)5>zy5M54pHu?<|#ULsEwLj#coN|PmNEop9+J3$5d2a@=N58F;u zNg@}7(nwMe1@!w)@q0QF6x;p=Kc>+*T`kVjMj3MNxFm{Sld(ruRndbKB+>T9z&yOM zZ11{-(Q*d51}3%^MgDc}-3u~}PcItnqb4OlwH#f`Ui^d<&R_mFI<4ynsnm&TqAu!z ztSI5DL1ACcu?(gIwgfE3YfLIIeYzW}BFaZ5U=pk1n#hy`t{@|fib;q?(J9h>V^$U3 zGIUj^+A&on^0}pLNEz+!GT|J=bFKTSA6XczIG~skhSkvCi26GqP{-AvPrR^`KGEE* zRuFetgDI{=K^_c7cBXfJQ9c8-OT~OIId1+PnWL9&8qS12-sHI*K3QkWvlv$6W3Mz>L9~en;*dSE2GqAS^T@$QMTJ0n>og@N0%kiyFo%hAk#cwjnZOXK! zj;w@yaqj-tym$Hrrw;HDT)4ech>pT`MzS$GElX%|+odn)P3)Nv;0{W&g&6xN_GNkF zgy=^yV4(7yCmV`j*kaXYvqj?yy;u4Sm+b?lwJ7p+=GgK5FI#VTo4Uf`%Ci$c@~U^% z3nbIcne+@3igb4;wCwNylc(uTaEX&$SLxxsnFabH@M$9A1=ezxL?u_qmSBbQu^aMdUORDOHa=)oss2JQVP-&7W= z=V)5HhUz!JVeY+ZOs+GYd{9@F12N6YPm5>Un&6O%!;yy8Q6#mq=HJY>PoJAyaU^rC zV2k9tsuSOM;;<8+f49$b`+EnrC~@p_zqq}`z0Y+aU<n24Ut+SU*10(_*QJ!aT!e+o|I= z?jcqM(Rn3lm8=)TYiyRo6ObhI%`sB7cxJ55oS8d$T<4Wd2Qq69&QAQ{xa@xAr(D1I zQzcPd+g3qH^@@`f45!&Mqh-Pb^Ecx2Yw@I;$D9{NAsx_w3F&xLbrbpSU>1ZUpna%A zPl(KoR9j=tjGDA|F+?<=Nw&7)yXv-%ZZZK-!YJ4PAUi^J;>L89nH!yd(t_95JY@k- z7yI!1TE@@c?Dg6M8~uI1y?xWAA~8U2c`;SVbaqy@B|(kxXs~928V@8}VXrh}JH9t; zQd@l37FG{{;Alx?;=Ik~pLKK7e)?wzVa7!F8`>C1#gH{1fb&QDTG4(hVLsXT@rB!e z`uy|Q)ip5M+oBR_c0^J&`z==bQO$G`k> z+0K>fRE;_o=$4MgvTfuOl3tN0_Es*9s-(yS>S~_4N8O^auM8?@lJX+jc`)9i_d0v9 zYd%_h*_SWAwdvz(r#S2^w%oM_i_@JbMLZE?FS1muT;2-WMlx#`oxH?OkGk9+f?aCj zzQiM~?#+?_3rSfnr_D+UO;rg>UJ`f5&_m-};N1DmXk6e?JM!hf7%{3>RA_k>Ywb;LVRes>Oer=+tb5-3*L`&1pQjB|r)>E_ z=%qLqLa;VP5=2le~CQP0f?WHTF$8emSl`UwIA|hiXyWGuXa8rj;i_m$Znw8p85T^>E zQuP{f2HKA(WJ6bpkMu1u3k<}mpjqdPvSzc221QS{a4<&9;6%?@PmV5zIwhVg)J=ou zU={%i<=E*3NU?*IiA$E+nabkBH2O776a8L1&G$u>jN#bsHhINt`LZszmZt1ZFid^p zoo?T3cK3bTCv>|jm~56)hSm!vef*Pi!ntu<4vTF_MYBk;yx>1y`^!V z)fAU^>}lRApta&m;+f zo?y~dPWB-@0VvSuX3j%=K?koB-=6X^U)ib^ij0 zqCjk$CJz*w(lyy?TSL7Hi#>(aev0~vKN(fQu_u)ls?lmRUE^GIFx*E5slZ9zu5|Il z`<{My(pLVRXET%#x2KSnuB{d-Du2TmPF_*zi{aSLTB-LXy5Pc{P7Y@wLrIEG_raut zvxIi~HdFR#r0MgwHPfpeMT$_!1m^)mg?o^LtC`A*WKm}k)ZYvY)#C(1%~Y15#`BzL z_lj8~KGQ;-D3`kJAuYi=bwO`s$85I`3)}S zSG0c;xxVok=CGRtZvK+e4>!2?_{DcJ-rpqy0_ak13lt^8zA$^5v*<-nJfE)amE*l| zwptY?m8({rR2HKGtM@6@31qCeJrvbOwFxE8h$qc^p3D5a@V-a-^Na^OtfNgG18+b4 zr%MjkOI?-FtJ9=c=C^Y?r7A68{w&M9KTv1M}Uw=W$QtBM|dfN%VyG!!s=%I|UwAH1#0 zOm}s*1PyND3A^vS*P%zW@Z_Gvqf$qEaAkMgbIhEJN^U+`Gq^%J0Ly~e*i+ZR@r(vDj-{W@)CX|YoyNBL#_A4h$SC_iB<`mMz zgAHh<>04e$cMMg%lt$#ZU2Xhc(NGvcbX3?59p&Ajs1p(hx{$9{hhSdJDqjEcYuMV zLuqE&kAtz}{l)UKiV*{bHD^)RfV+nOckaEX z;;pV8WO@7c_ka7Odb+BsZrywC$>%$9a!SpDZ*8nl$UviJd{D}5Rl}s7p4#`pRnwMC zzHk%XX&mlh=3#StSb}DbLZKxFL&f8b1Eu-wz3Z@6k@1VllnsU!{#*EfSEG6h+$(=7|qC z%~pd$6-W#01&1PzB8I6|Dtwv#ZiC*RL>SD3DwnVSQPUYKc4RCWXMsq;++-`h39Uzj zCmo3YcRcm&Ux&r6;3|=u6fJOwjYD%xBHq7)#oMsu&6^(k&s)#@llrMG-eB9S)InbX zGi4Xk`X_o@fR8R9!c*=l!1rsb^{pKhaIjFeQRU2NW~M%V|IeoHFYDKD`!ATY@P^Nm@U0R_x~1(Y5&_9nPadWoV7C+x(rAgcI>Mz=2TlKO>g?t0s~(`nD>E+gQIT$;H%O?~7{rxK zQEO+pO?=xm-i&7Vaq4(4KG9XQotj5hlsAkSH?g&)F%`>qHi(l+48Nhh)rbwrG^UZ$ zMZW^l3fz(Nf0(-If_Ki#@#`!MoYYB=e0uYja}%v2)fM*Zkm*xA5Mn~K3()hH!_R;0 zU%z_l!t;4FUWRHf@#Lz8IfL5FmI@>_%E-1+ z+Jop>s?h$gdUHL68WPUK?cl>s#k$L(?CEq6XMe*sTq5S8|c)V_bn z?71WE&T$5dLv9K{=uk7us#J2LMT1qZIRDJo->*LKau%QE9@_H$8FrpmzqYaBOl~T7?N9RJ9F$M?L!U7vrKGt18=c*S}q|>4h+xEC-+$_|u zMR_NhCw864l=Ztmn0LqFXWi_ZT5Kz|J!)olrQ`KOXSPmHC41msY435Gas_;~q4oiC zSVE@E@J?Acc_J>;(uJf&Z*4;}y$;pCIg3M7R7z(z_);mF*;lTzyDcv))#tV0KV&{& z&Zq=XKEjBKd>P3)@?19xwbSd6?Gz5#I2^f?Db7_*_$2%hH;j3cDb!VFa(X~XUr-oq zO27AZzT%)K`fZ_G?*G;N(J&Ayv~ccap*eys}2EVM!?;JVJu=u5Z{EiS^m7T$umz^iZ;2;%j= z=AtNxicJtV?4k_G8g;!6E4{1{H5cY!%n>C8T0KSZg|E!QfTtyj3ho3YlADxTgsc2z z79<<25-$2djU1cM9g+4v5`3VRb|voNX3Il;T>;s+<)c?VGMg@mOug#(`CqQ{>L&Z> z_H9vY`aj*{CYkee*OrybtmDl-3FvHRp?1C4`!eIi?;d0P2cB|!st>#4;pcuB|J-iX z`l;4>dDgJg56PokNkGIE8ix<-9|TLwvxQe*iUw*W@kZ~~qpdQ|?W;6nSzqud*i$)e zuZ}&x>bvnhzg4R=Kpl%rw&wa;BbM&~GAh~!HMX>;J5Qgo@W!X#-}?f!z7g;4vq>R6 z@4+M9TQzMIhlkwH*IP7P?LfKR!t_eDwl`$POrP~r^IKw6AN0eP!^X_h zyt8m?(b5$L7o>S7r)M=G0>X?L44eYVBlKd1fv&_BG*IzCy%OSpxorgllRymA4wKqv zKQ?{Y`;Y8&=OCUtZ>EzycbWIImu!9Ogv1%XZA5~xA=nq>6lZqwIfD9jQ{SSbriTj% zy2ZqVHWoLgga|}j;Mq--J{stOk+X_g3WqKtH<7N_xDVz^<@#dS9`8v_s)oEP>b;6` z$Dmg&aIoC&mWotG?T)9uc+xpDc};^^W7G22?;U!=S-T&ol%0Y0ek?k7MwXaWC5GqyIdkEArpSvebGmUTcS+&jUHwWLe0Cf%=z%vB?&;b30r_vTagqU z2XV1~(TsLDlcFbyoM=K`7e+>h7@P}aFCk#rp}8a`ij$@0q}9RJ15T4ZosDOu2y{I( zZ$_p-3xZb|6B$`%vdS$A5QNF4Y6fn6c>gD_KAzpUUR*szU=i>4HlNA9KXc%AkG$H+ zQF14b9+gL*Yvm>@%raegtj45teHyrJy+dP7JNafZ+lCqru*`I7?>T4OK7Y@|Z+LqJ zwUjA|v{c=@`ItU8?&^mZDApF2N}dtz%%y>D505!qf64<)D-fzk#KTx0EZ;Si4{B`y zZ*5Erg@W$P697uWDCHT+QW1FkT*jD7D zcX)jwU5{)xDZTgI52O_%br3ClaH}C6%bem-PzwZI0nbc0q?j2-3g((41&+2CVz7eu z#DL-oPdPcs!Ce%1ldc_Te4>wra5?*Le2`*2FxseZJ%E&mx5i54WAG@Mhz#+rpifZV z+$FQ;&^6wm-@*BV-_en>=j?BA9~y-_d(J*>mbFp#ocx7+wi5MzT(KS!^;3H*>QP+m z6!oPhX3s0@gYxvc?l|qm)cQqttj9}AGO0$@Ginq&jV|U&plXo0QD!^~wpM)JO`k~j`%nG)gI`B>KhvjE zix`OV*Xosg%a^3u{|E<2UNj4XV%po~S?f7cvWzX1K>(_r`9lpUyMk+AyW19x+GN`F zDPM(4Wm#u#b_!8=i5*LhAKV`ERa%Np1|U;*K^ewik%}tPQfX0dziwgwLH%##h(#o* zXsmlt+jZyOGW4k@l#s9`fml+dyy%yd!dk+p&_G|&=-{f*V(z=D`QgDz!7pYP^h3fi zGM9Kov~kb_c^PrR6WcnuHeYWL|E=MU2bNy9GRgW+5ZYErWX_`4)7yXe(P#hTBkwg6 z=CShwV&P3djo5#-T8%k_SL zJY)8fV~!c8rr4nu6>Y)!e9WPy+ggNOQt=#(35Ie8k6I~boJ}wnvs-tSy$$+03HVNSepl7J8Ws|5_)`{FvG*i$)e88CDsWM^`Y`yTtUl94zdJ9Iqu`BzC zyrq}?>OtT0`LLs{_0QdF)3?sL^44WsTj0$35$zI#I+!NWng&4Mf)A9b{*5wi;kSFg zK7GsIjjrP?L2qXU9vly%Pvp4e?>@W5Utipj!CqY)ea*sDhKWNxL$*DXP7s!VHw>j| zj7c^2zwzY$XB`n`QNWwSJBi2b)i1Z=*o!ZDNu98#kc=ZnDbVSXdC>r~oV%P7XNTu- zLMJ>;;P!IE!&WL7ruTI3m77Mti&XZW`;`O^LU%Ky2Yn8rcmgZZfGv;l+ zDoBH*b$P4e9bNh6pxU1OFFyU!$43pnjR}_30spYh>$mSl^}~LD)yaMrQFud1LDPa> zozav6{-E#}V>X0q8riku5Aq;`50PFGo!+d2mFLU7a45nvWWuGuEg4KS91*)-L$K~- zKZ1iB3Lg;Q=%osc{t}joOt%3xI78JBV}HI68@$Sade;DbQ{7Q``iI#~6*S=Bc!G5~ z7&bEOoh~O}rIZVQRT&`j#ic{USk2fF;jf|}t8dDyNO>iZ>8QK6Z|-s?nbF}stAm-k zpO(*G{_?}W+xU9p2u1eJEyjH#wVTXIz0O!5d*h^8E?H7R2`$q<<-eu$jzSv#dt!kA zFbqmTQzh=2z+cSgu*5phm#)R+QTsxHNVN92`zZAALg#`T#&>UFaho7-UrFSW?x#1M z_-VsdBYZ1Vv}Z|^L>a(3^&Y>ep&q~0fVwUamsR(|7g$CjOcyZq^nz5AZhf7Q#Ynf742Ib1nTeUDl(=+3LtTe9d0auSq8u6Td9 z0l%AD^S7aDXam(z22bkQ2K53bikL~c$eRbsCh-x}t>m)hBidBY%2-o|;_ttHWB*mx z>~icP7TKKh9dz_h(3O*xeA(yW9rpDDvn#p^ix>_CTBQ3T z$>jkcyc>zh-V){f5EsrDRY;$>h|1nEg{zp(M~+kW-N3MSUu1BZNF z_ka&}IrN!Mj`V4V>>0f0s%iH;`q$(Br`^X$$wK43qtPdWM4golK+LqDjPq9;h0C|q@L?inJ5auHwUJK1 zjqvEnjAG}{Y^m;5q|1yAa|gOic&wLvVcx%ZVc#q-*kAaAkL2&&>*x97Zuq3}ZKY>B zeMYr;E*o?KJW?m-to)aF z%*ub!tbQCV8C_Nqg<(iOaNY}wudK9}7?PIJ%&|M07Fd8oMBWR+t1>oQCPF;!yq7WL zokiXYVzU(gK~#0f>LkA4g$pFU(An^|l4WoKo0tqUjuDH*m$D{r;tNJ+#;1!*Fbgy{ zPAw0>(mm)U&p?dLvtU*=l& z19)?6{LJmIRZF)Xyl?+qThu8huN5U&K^%%ARU$M-bOqt83rooh2x|>7t!zW8b9P5Y zQ$sZ;{n5cseD?M3yrF}^Uhbdtk9+q0%m3`~8_j6NC`OvY%xvYTNo54zm1*lvNiVQ+ z2A7GlwM?$hG0EDg7p~-(YsBkOuzCLjd#zg?`}2A6*VO}A!~5U&-9z+DfZAqz@MpA=36_!pz}iMB zWPiIX(b16GdFP+7eAva4tkw6pW*vT{N9H{l8TE&bkAJ7$#JM>n*%y@Fw$|o^ihm4)zdE5VQx912XpPr`V(m4t_j zGho{IC_k$|=zHAP*S8JdIUFr~11Fa*MYa*DQs|E2=FW3wEZqwa%+jh6FMYRktJ)e3 zamsu+kcU>UCln?rtCOZcT$)}sv!SZBQ#kj>N$%#WiKZ2@S{UR|5mk};+dennAA4x%k4zdt zv;Sh%OZSbs{+ol|P%mUF<#-`G0;p%GR<$=?3E*LIfgA=sQ&w{q&_Em|-!S@6@(ooI z?Q2zzy3P^Yn$FDtAek|?8TrEPt$+_m%ll6+ZJ0f0&TPXRG)DoG5nTYBn$Rq8pfYYB z+{dWJOYU0u$_G!eLN-vn{jTcB2YUm(GOypd<|#XE=Xb3Bw>UzCOwmn!dq-!sy)8LL z99mUYm#$RI=UBDTnp7Pxa4R~2uhdFDRGC}v?9dbym4o?AeIt^psX2@WY$;eMzxv3u zTc7{=xFfl6kJnUk5d&N#Kr%aJuxbw^+DC;8LbM>S%jEK^huApTLQJyo*q|1fXN0X0 zYH&uw3NCPgCmY5 zIg!|pp;*Sz*&+K87p$@UD7Xa1|eLsg_h;rqK2T%i_d<8Y) zNp*ELmYdN|)hI1qBLts`w(Rn06%%n@CQtJ)Jf1B4)=bWU`BjsW`Ss3&;NtGy0iV}#_ zw7Iz{^{?z}0lTsY^FFmtU?10fe9td?jK!IV`LUC0INYEoa%f=`r60^)>K@<2QT!8i7 zNnWTOvRvb0kXbDxRY|@&Zv(0--7avqP%1u+yCm|#BV#AMwQ>8fJ9XiyAU~b z2IEH-S_+?5C3xf$i42-nqK5-e7M)9Ej$14#exYs#-MBots95KvoU0O zik%g!NjJr*0wPFp-Rh+;s_%YutJ#XgB33DjdNhmRlE_EzAM$APkyjiuUY)V6b$B0& zVUsFdMvTh~+k^x_(c!xx)6v20I+8pgzfFdGt>}Gfy+Tzv3?U6tSq=jl(AL<;kJnfhR^>mk$ z99RI%Lus<;j%GOuKgG}JFN~Ph$jLw|ait00vUog|lVG@FysDFJhoh6Nb&7r@``BVi z%yLu~LX(!007`Y|i{VOnCfSW;b^1|cb6ea&bOE9MS@+bvy8P#DcK?aFz%FW!^MScQ zpU5Xw7rt@bx)0sELY=aA8Y$w$255ct`jX|cTRm@`1Zd3I_4;A%H~IP~(Bkm599*I9 zwIsXkmbKK9eQ0W({wo%Lb?^`i-9E^O{G{>X`wn~W(+xR_%_-4Z7myj1xY`SX&&5k#dM}B5nw<0IhBJ5nO~kK* z^{$kT83eCVXgS^5mn^z+I-g`A%tB4ay-j%P)R8$xN#yHAtB$|^=&xpP<(olp3{lP! zOygGVD=q0St92`PR=-MiC`r*#?>0toNfikfXEpx&)q!^%?7{^?V@iFA&Es8He6gVM zbPGQ!$WSYZe3NXQcfc152Cy>5CZtH-EX0G=wo8cGDa-Kzc8b!c!8^ zQh@1xxyR^%FJIPh0CPRgE)F_+=)n5ZCWs&U?Y~{$XWxIIRh_f>B+-MFixsNiP7p*v z8m^=c1D__epn#-uR%dx*7SQ_8f`eqyL4#`+pY>w@6ItRh_!p1Y9`29Ht#_FE-ftc? zb@VHzIxKJOKRgYUUV`Esp?Obo!|1{C55yM|~s%9-`Jjmu*y$r{?v|$o()3;h?H(??Q`u#e<3O_+*W!I4e&#q&tu+nuqO_ z&%~?nkNOSzK_~J=Wa2u4PeTcm{9j<%ozxWpH59b(KifI}_&?L@|IEb5h7ZpNPsC4m zymIBupFQ+Sg>M>c6U>{ht!;E4r-FEl_loLh)seGrT*eO$W;i9=-qv+~$NJ|p!oe^# z1TdT;@uZcPtc;RyQH2XPU8!m?$WL zuLI^1Jo8kF0#-nmIZYMkY2lfbe88WEXy3)-{HQJ3`O)W`cbuVoMV6iYTLtNnT z#}#ZRVMeC_C0E7XbcB>Nyo6L)jqr{zvZ+sn+UpV&2y-WHW=7jn42l!0Nj1=yW?~8g zCE}-Ma#V_$gYze|6pjvlGRyi28NHNPj7YbM6V~?}QN}tAEIW0N^TvMmsh7DhlkpzC zOoo|DNo3uoPY-!;`?fD?|7$e>u~9U1?DiXUDOZC|0Vq2ELe#KHZ%i{gUnys*6^4C4 zSa5`AY3!Bhdv(btPhC{8>yEya35{3?#Q~uP+ZiS%0b~^#eprh@Cz69{;tVk#4zJh} zRxE{(O3YZjHzc0*g~Wpk#5a3sbibQ!UHnxcFLZ&ly^7|pR^&?|+#}}H&Ji=p=t~$H ztsTg_0;g=q?|1$_ub#eJ_8!(l*x2BOw^w|db0)s})2Ra=HGP3#StV*2lwmr#@E8&o zfgwIV(~(JcvY2=IHkl|w9l>igCZY<*bgp0@x|Q+*vM*RTXXXAIZ!_wKY*Q9N-8Lc` zlvx1be3o+O&T%Koy1d6C+99eku$#<8wdFpxZY07eh0iHU7l`xDBwK23Ta$YG%0GTE=DtfT z1gl^lXutVmX8!AjKW(?l$8~IL#Gf+i(lr0WEkZ%{x{$lmlS(F|g~KL(0gJ+?bH)jy z8o9fjNVSxqe`jW%2CM+e0CZTwVlop=2)_|nf0Lzydz*4l!$e$(t5~LpA;IDdZp4uU z+{0ja{0FD-EayW&LG~9!t&}7WA0iLman>yB5YBg9o*=tMyxgnb-qX(7T&BJ&mq&gi{g#qoQB~8DZOg##fgEXonTo$eVyu`PS_#(` zuD>dAhf!~Q{mS1D-TpS_!@+*h?fcff@#F3-{q|As&}_X6J!)`1Uenr~9NbblrWwXh zx(%r!nRIJB-PPHyRJ2>-S8jUCK@UF980oC0srv*T_&PoYU1*Dp9UtBJnf1?pZM%#T z83WZ%9MfKuurOkc?JW(+i6>!E%I<2+S_oPU3Kc`#?J=)*9_$fSCW=K0-u5>IN{W4e zyDada@Hm2bQ;0)$aPSDKhcKQTVk7Sr8&gPXU^_r+m`Z94aZ3&G1v};l+k&nZPd5`I zEuq1;DTRZcLh1g%7kcFBkm#JHddz$44Hl#{{7!vJD-8TNorw5Re0Lg}o^|K2etYcalQy9`E^Wn7Qc_Kf3`Y|qH5bA!Ot^`Hzl5sAs}oi# z0F@{nI@kf~DF#9sdj^SKxiScoQRulq%Ut6XF|IYyKqm(4m%GisxqS1}pYNILpKVb+ z)$7`BIE}dEHFPOdJ*-jQlTRs=D22Lo;_18!p^(n2)9D8sDvY7j`KR6AJD&C{*24#F z4D?YoevOUk?E@0bA}d_7?4dfA|E^hxDJ@>RHbqcDx07py!{C@&JSGCCvp~Nh; zQ%Q)XD&tWlSc!MX7y5YJ@ypL`S?43;*ZjWR5z$YQrFXvn{R{6d|D;Y`>RQqwk+z{j zp{6LW-cY=T)}`$hQ|fgg&BD}_!C`6&n6bMm051GMzM;ma$cxre~pX}uKxAY&u#l@tvWSK9YstP zTZIU&5F(zS%_zYod+HQL{ansS2*fyi?*? z`r7N7m|uGTj|;y3)>M~ts3TFNWPo};%!87tK{|CJHRZ{Bo@x7A7aMpiO!?>?Q_%O` z>%4#4?~X?U-HxeCEqQ6_9LD|j!W_Y><5?ie81xp zXQsC00$b;U!?N0o3~egTY`9zHf<#s)w|z_)8y@2$?7_i=E$CD$DE(|$qguy(`9Chj z3H#54^MLfy&2D`7QUz>BT}=ezk)1ZpH14L|0or+tik6ND0Sge#G>6Y6R7+ z2#eBkl8ea^94|yRu1=Ap8N4VAprn~_G#K%?%iI$_#5dvIt!Y#KK|Plp^VYP*gBUc6 zmxi|7;CxeU-Hh(MF}Y<7f_Z?y%@cZSYGzj^H`}N{T0?6p-_-%+tWL5;2#;0o(`lH! z`PA=P_N?UEEtY0{R_b-e`6 z)suye5*^`rE0o>}e@KcPBhj>=GCR{1-ysh!7$}DDq!}T`jMk@mp17d)iu<-J<%AKI zBRpgOt|L=VNyME0=*)v|?A+fUlqDOYOxbv0jy+51Nu;ECz&cp0wc0 zS)B4p+bdIf^?tuUZr{0&aoL7*U)Sb=PAe2?e}F{sVDey+GrJT>4qb@Sp=PY6tE;jS zxd8wwN(WZ5B*%76>N&5wf;X|30oenr+WY$<-JAXT=4;fY1Jyf#FBYBC8wBtcs<;|q z_4c^Hqqqk1LbZ5-YORd@>BPS~kYl$%tgIn-ny{s!IfwHNIDWGGdEo|#qrFr|Jc&9S zx+4!tiQ`RG&?|&I?zW~(70OGeQ-}|v^0pH!migEeFtjHz_mw}CPg$raz$Q^>8oewh z=1LGrwyshe#9S@6H|rYYJ#x1%@H8$!#cfEqpnJ^`h~yu-%zeMfBOUezyn76XG?N_v zuynv#@KJsiAL(1HJ2_^Z{&#+wm*?<(MEM%xgk}OA@6G7s)Xe#lm9CI6W zv{$rx+w_Gu+`avA2dgvoiWX%mF|4r*_V=rkMmL|h`CzMMDw|(C2>a>7doF7G%`Fe# z%hhwvr-#`X#aMD|XR8upBDLNtu>hC~AuM0tfK?(w0z0m|O5y?vtKo+VxV|NIxf_xLs ze1<4M9_{=G!u5hLI4^^|6dQJ5jjSIoku0Pjp(qqI!tZ3|yVRJ;q1Ly~#)BX_tOqKj zoE2$yEgEu_kkk@GuB^ChhVpzHE|^zRb6QiirNa+6`Q!SpSonF>92P%)B9rFdaKZC? zJzm4`Q?~f&6;TmL3lmgmR>SxZVKUy!yH;O|RfW%*O2=4%)$!&e`_LhrWKhQU_%?Dqn|14GPZ5rWBZ6s$+|d zfoao`%`}MS)6**nGC#=OG2+N;%HADY!A`TtLe@TfD$wL}&iL`>C+}Xl#HRw`{RKW? zF@viZmd-beoT2HJ2GGT*!8M#ESvZE2u%nkO+-JKS?~`iAeTc||UW~Vr+z2pwU}(2e zK~1Yzl+x6ZR~;~H^fk{~33-{oH$SXt^7|_v-QmxBE4EszuIzP&k6|^ew<6X>koA1D2LE1KMXUp&LMmUnES0HEO+V7U8Kt*O*F_WSo6x zI+;%g1>-`9%`Q?AM3733rMl^yX+Vus#;}H$xs56KF-iGzEuT3wHT}HVU){3BCFgMv z#arMz>F<7f=d<@8^tVU;e-6{0t8}K8J9AnKa1g;A;$6jZ2L~GX*rJl!ba*z{ z>mHVZ0g$8xVUeg+ywPTgX1tVg)fF2w<7fgZL~S9)mj~lB33msQ8@td<Qj0yzj9E5V>E*@qw30|&)3~44|Ma~B z4pIBSodP3U#A~yqoJ>jDm~wXmP$ZWcu*(|;?Y>+5RbZ`kUzLA zWuB3-WS-Hf1QHM!;oX2950b%WCJa>sEdV{~ES;=Is-p?VFp*gt;Q9D|Q1f)cHuBs= z0Z5sN78@`L7mv@-m6D`uEm>|<%*o{1Q%Koq%+8{Uh7?N2$u__*YNSmV%5S0IB}b6L zhk?k=<&Ss?xJq$_JLWYt)jeXz*Zbet7*RA8VY85r%$8ZYnQ!biMG04z zC62%Xc5SHcZ@C#YX$(3yxIhm?_73C0K2M4tyb@4HjC@huI7&S8dV{BCM8i&{2TK?#wYSjcKP=+T+9V9#p9^l3N+66h5aw=T(~ z$7}St6_Vop^UZgjJ*#?;VY{88=G&%sQYH%|%d@h_?<<+E5tCiC+a!?7cp(nKaqP5H zx=wiTMUw?YvqKv$T=(25Pu;ie1%p^G?qbqVM|<;jy)^c_?f)k-?pxo>VB^ZotECbd zVL3 zx@{`@WZax8unjKUGugmc7E$shu~y=#}ZGw9aTtJ{ibeqI{yb z2_T=62Wdu3GHw>?A;&8h-hH^hL5PAhjiz7&LtX&)N|;ZA$-u`a<0E|}gX$tc8^ArB zOw~~TG4*yDIq3JHRMuES(mGM-erRe|&63hbn0Tm}?0`avOI)H7U7>$o_Q8kWk3E4s za1r*Ics84(lhT~MCs&<2Y|^Fd(6p%ryR9~F3TLXXdxlIb#(E+{M6@v>NiilTiyQ@+ zYuk>MspO@K?ks9KQm{1Tp3vtLT8+$rv6y;g(bxYdo4c4@IFT*AujJz+M>oxmG}Ron zylai_hhM5Xhzv-eZ3qzyz&v*Ys?y^3$(*o#GRMD9;4ukGy&j*DK?h65J4|s@p?kcO zN{jQ;W>*Rf!`lMDi24YVbvHipYO)wuCvxm}XP-A|+w225zoNkPf|7VN3WJNKSq?6Y zR@M~)ik7Co5bY^pVC6eoA4*Z=AlA;PKm&7fJ*0Z_3jGuNArznhj?NJN<^ydeoj!2g zC@Cu#hX5w3e&u{6`B5s#M?-TLOF?iBiDKT8{GgPsV~0L-%)fI!A+j}7i)YUtTlUo!6V5B?*Ps~y zQr?0^pi+Z`T!FTOVZ_Y|#GJ@omcS=eO;_h3oGJ4S@y&b+D^H&}IXBbr!rqteut};X z&13wM-PoQnmPF=0T5T*@@cx_^)ES%OQhW$FSHb*KvR&{9nyAEt%*-JfxV|tB6pL|% zs743{LZwxtD5Dfzr@9fb2fLM-KW&{BR9c}eVzcL1rVY)7bs4WuHr+k0?VaZ9*>v+B z)f717(eXnc>A%ji``yR0;`ECam>C;lF4>%E>B!`+z3ZZ@cG~jd3GB=BKAHdakKp9_ z&ky);)?q7m^)VjHa13KP|KYe21tPiHhS%b~gM3lcM?~lN4u&E<^_)Y$xw3uh6`V%q z<`WDqrsot6C{pZ#3P-roAk->ATRC>bFr?eSV-x-cAZWxZYqY=>) zL*~gSo0M+p$~f)2oXm5>`^38+)`=_}deQx744&L?Q{R4|O0#05 zsER{yqjaI;XiX8f3C6lmZK%^^H7xdIut-(nv{vIX@muV10cc#FN-wL(ZT7>;i9DZM z@Ie(a-D$v8KXt9Ufnq=|N}HnGdxF;d!5^nuV?nl*L!+zDG^oaTAevAW1fHwH zDhMv{m{`Gtrj{&FKT(VA3od&DGU_`2{&BUJ5m(_2{YDz9r``BA>?u{iM$%JikdiY@ z`8WZ{E=%*6FfG4mr^7D_;2ZQ5b^glAQjN8?r0UZ7Y<;S(y#Yu!jCJEvu8?}bHz7xf zK;gkk#W84S)|(lf<;%5Y`N!mB(b0Dgoc8#&pD!JzP7G8>iXV=$Ts}n<*Q1a-mn|RB zW~A^Rg7K6E1IGI6H}+q3%`V3-V#EwChYdP<$5#?Lv+so0_Z)oP<6H{hqIAVi3)A?2 zThu*Bj*5Viv`EY-wL@%2$pwJ;RDOO?pRV9y%d`64aDCe@um9>JwJNMksR}8XNLNU7 z2ow@fD9ro#pj<9J8@gtAOHb<}13L;WJu@vCdX3d;>q!JcKK2j=H2}i9bLy4%jxCv! zW-X5;e~^?biJZ6Xaf=T;Z1l%(`lVda)hLcwC(AC_oQ31*lR|j$q&3Him0Z&}MPt77 zBMP~R_4nZpWv$3iLS}i4qv#VD2P#ukmIuP5t^y1^(JH_&#~~gi@{q6_%mn5~WqI&z zN^u1RyXcO@BmG$(kWMbBI`vC4F0wq-U-&7#m6N?z;?6S51NRn1EHhG^vmw-|HS?Cp4wtH>$X{Bm1Xkv>5fdp*IhFn{&d&Gq5R+=DN_=; zylMR{H`!~_v8Vd>1=ephYjk>}G*2F>bV-@+VA0&TSrsP1K35c zk^%z9mrg3>U%Pc-N^c>=L^Ixlh=fuh%tQlR#ZWH11vzJVrL>F%W>o=ICq3lW^c#D@e z<6|tIh7*$Ej2BV-nS!z5v)#c7nPm>pH(U>0V7$zgL+;0<_G|;Ck5DVdkurUx5pn&Q zMFkvmDKDOJR3kN8(i?J8g`d=s?2?!)9;F6EAqU#GCJ;S1#;ODW#shwhTO&uG5bHGK zmFKMjHM&;JsVm=wVk(U4uIkqShF%UBQTao927U!}bk~N#4#4~;dgK}qU#Dpl!vHsNB#f9k3UU5*}w=qF`P$ali{Kg@kj0TL32rUBf6-^7=3n`iI@O_$Yq|Ozy1C_gOd$sc z>H-)D5JKUS2o4uTvEPJ00`mmrF4((aM8#!xv3okTAo8d67L0mhS1!O{QOG(Sf4{F! zbn_(Yk3l%0C6U`dn38(@(dRGr%RY!cmHSeJsV-G07pdd*;k$BbG0Y`H>(z|*5RDNR ztTF4I1L+#vIS3=KFca)yw8b6*GKZ*E%Zv@je_(0Y&bW_L{;ANCul5VSssS6pE~OuG z)3mX^rfESDrIN^9=gj=o>w^x8o}}o&Hb{wd6T!ldRrua!N#N~}PbMZ;;RN5NmAh6v%#<6tqAclBv(OrdwhynKtZ%;Rj#& zraA7}r}=$ZE8z`mbH9hKKJ1CJI))z3skzQIRK+!Vhp4;i41++$p%a?7!cxkAJhOF5 zzvuS)I}au(+EfyG$c6%eqNlHvm$MZYAs-;Wdvw9|?X$>uv+ z(zAzT>bjc7BM%Z;6}EEfMinvR=oCrS2V_8MgBk2U@K68KWs5)hG(3<{|TsA^0c z`FlhX2eP2U{XN!2Mnd>|Q0EE!xqL?XqBX`+vNfHXk;xgx*k;6d+gnj7oR({AO!X*R zvtXj@<0aQ_UVrzC$IVExbBE`LkN)|2d-Bg+u^+NkNBZ^%D=o!r6U*$eTR8up>r13| zk}fNGl6NOjk3qB~g3z5H1T`*j3To>d*(OSA`_p>W?_FsHX4Kz_C^%gBPT#w#y9Yh| z#^GvRZ3ah+SBjwp$y4QffrlHu7xHJ(rM^gnFyI?9$Zt*z5&w$MSKZU`^c#IvEN7z1 zFjc9eEt1|X>uUP@%6(r97KlOPv$h>zkHoICdd2rVdj2Off6l(aPv0u=>F?dS!@_3{ zIU&z|9S5o_#nu-EYl-(r|A#y<7`Tv3h4E)5oAEEL)n&69&=biBdKStQH%7q0N?%eU31VxNCh4zjvYH*0%6OQq(%k zCL;wpMI2+Ic`=hFHNv$4lxTVxKZ*Bvu=DrRp+DaA;P>BN!0Gii2P{^_^VRu<(%V`D z7AUCSHF;^rtHg=!+0zL?8y!f5`c^!UKuP4YM_=9O(z(+Pt5KWX)|@DeN`W#YDrkG4 z5}Y?JZ6cL4yXt3TI;U4A(?|?MpOS!_jHBx({A%QBZ!KfJrHWUc8I3wJzgZ{pdEbZ1 zmuFx7a)>%(FFZyUyuqCWOj}vogt`A+=MTQA?u7w79_gKf~pYBYoIB@ z42d}kiMd!=%)TmpR|rAOD&`?P*s?a=hy^0gKB&Ur$g}NP!z{5%KP3 zyt`1Gh8&N$T*heSEHpCyqmnhsx?+oQ|0riXf#jeZ$>mkL9Sw|HIr)s=UMoNho3(CfyIxr@ZjCRN8S|nc)mPm z<8mYZ^Ap!<##5W0DHw*&dnhUqMOzQdYa&%q!>tR0xCn(vsr74FO>Q=UR?0VR9$8V| zFlOAu)|SRpEZ^A>r?M5S(d<0%Zs?ws3T}u=Dr90r+ zz53~QXMXv?bL;U6vGv18?{ND>R$cwwytz~R-gK5)!~yCO2~9yEo?;l5&RZg0#T7?g zy)y1WVIhz~Yc2#Lcc#u^g6bW&>rpWll%sJ{3qsmp4wFO#6CdSglfNY%ftxsa1V7Ci zLgf3n_(06?f!=XWwRcrlmF<3h*T%J9Gm7RgYfXg~r_IKdPEz0oq68oPGFn;;*jJPc zMgCR!ZBKKyMU>}Dn(zs8J2^rVjW*&4Fvl?~lKWvcAlsnOpxB}ud%ZIQd`Ax|D=@DM zr>^3HH5UAmYoRIJjr)K#X_FddZX2%@I~yf}WsnTBQX}e0$tE0_vR*`z zpt9%16>y(W@+(zEg6CNI6!>wh3pc=N7e9oH(Ax(iI2!!pOC@`)Q}g|KZEDHwb;b56 zU|hp#iqXVU2~ne+tnbPrjuFKE5cI4Vlxq^%ym_4!F>K{=BdW*z~T9^$F>x_9lVEh*n5J^GMik6KU9NeL=nY;+wr zv|gA@&)67|E~JJnHb(#x>?QX@Yd{zGlf^;IOPu)&kzU5$p2|@6E4a*PUl-KUla5Nj}>THMWpUN%eYxrdY*HblD zRvJdSr6)Z*kNl&2HdtZ*=dM>yocH=&AF>78hm{Jg

Co6aYV$M3 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

=0&c${zVT%4rB@FcnB*Z&%W-hJ$_yZR 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 z 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 Date: Fri, 18 Jul 2025 16:13:33 -0400 Subject: [PATCH 10/79] sketch of constraining `finalKey` for `master-key.prefix` Created using spr 1.3.6-beta.1 --- mise.toml | 9 +-- notes.md | 12 ++-- src/rust/parsing/src/command/constraints.rs | 39 +++++++++++ src/rust/parsing/src/command/foreach.rs | 18 +++++- src/rust/parsing/src/command/mod.rs | 72 ++++++++++++--------- src/rust/parsing/src/command/validation.rs | 2 +- src/rust/parsing/src/error.rs | 51 +++++++++++++-- 7 files changed, 153 insertions(+), 50 deletions(-) create mode 100644 src/rust/parsing/src/command/constraints.rs diff --git a/mise.toml b/mise.toml index 1a3e9abc..208c9c9e 100644 --- a/mise.toml +++ b/mise.toml @@ -37,19 +37,14 @@ run = [ ] [vars] -coverage_options = '''--ignore-filename-regex '/.cargo/registry' - --ignore-filename-regex '.rustup/toolchains' - --ignore-filename-regex 'rustc/' - --compilation-dir src/rust/parsing - --instr-profile coverage/parsing.profdata - --Xdemangler rustfilt''' +coverage_options = '''--ignore-filename-regex '/.cargo/registry' --ignore-filename-regex '.rustup/toolchains' --ignore-filename-regex 'rustc/' --compilation-dir src/rust/parsing --instr-profile coverage/parsing.profdata --Xdemangler rustfilt''' # TODO: generate an lcov report I can merge with the other coverage output [tasks.test-rust] dir = 'src/rust/parsing' shell = 'nu -c' run = ''' -if ($env.COVERAGE? | into bool) { +if ($env.COVERAGE? | default false | into bool) { $env.RUSTFLAGS = '-C instrument-coverage' $env.LLVM_PROFILE_FILE = 'coverage/parsing.profraw' diff --git a/notes.md b/notes.md index 1600d9dd..70b18997 100644 --- a/notes.md +++ b/notes.md @@ -70,14 +70,18 @@ Integration test debugging: - [ ] start by implementing parsing of `[[bind]]` - [X] basic parsing - [X] merging defaults (unit tests remain) - - [~] foreach expansion (unit tests remain) - [X] refactor code - - [x] initial coverage output + - [X] initial coverage output - https://crates.io/crates/cargo-tarpaulin - or look at https://doc.rust-lang.org/rustc/instrument-coverage.html and use nightly tool-chain with - - rustup toolchain install nightly - - [ ] validation that `master-key.prefix` uses `finalKey` + - [X] rustup toolchain install nightly + - [X] foreach expansion (unit tests remain) + - [ ] use DeTable instead of Table so we can generate more precise errors + - [ ] validation that `master-key.prefix` uses `finalKey: false` + - [ ] expand keys in `foreach` + - [ ] validation that keybindings with non modifier keybindings + have a condition requiring textEditorFocus - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region - [ ] validate by checking error reporting NOTE: short term goal here is to support literate docs diff --git a/src/rust/parsing/src/command/constraints.rs b/src/rust/parsing/src/command/constraints.rs new file mode 100644 index 00000000..071130ae --- /dev/null +++ b/src/rust/parsing/src/command/constraints.rs @@ -0,0 +1,39 @@ +// constraints are validate the global semantics of keybindings the can only occur once a +// keybinding file has already been fully parsed + +use crate::command::CommandInput; +use crate::error::{ConstrainArray, Constrainable, ConstraintString, Error, Result}; +use crate::util::Requiring; + +fn prefix_is_not_final_key(val: &CommandInput) -> Result<()> { + if val.finalKey.unwrap_or(|| true) { + let command = val.command.require("command")?; + if command == "master-key.prefix" { + return Err(Error::ConstraintError( + "`mater-key.prefix` commands to include `finalKey = false` in their bindings", + )); + } else if command == "runCommands" { + let commands = val + .args + .constrain("`runCommands` to have `args` field")? + .get("commands") + .constrain("`runCommands.args` to have `commands` field")? + .constrain_array("`commands` to be an array")?; + + for command in commands { + let command_name = command + .get("command") + .constrain("`command` field in `args.commands` of `runCommands`")? + .constrain_string("`command` field to be a string")?; + + if command_name == "master-key.prefix" { + return Err(Error::ConstraintError( + "`mater-key.prefix` commands to include `finalKey = \ + false` in their bindings", + )); + } + } + } + } + return Ok(()); +} diff --git a/src/rust/parsing/src/command/foreach.rs b/src/rust/parsing/src/command/foreach.rs index 3d160396..badd798c 100644 --- a/src/rust/parsing/src/command/foreach.rs +++ b/src/rust/parsing/src/command/foreach.rs @@ -1,3 +1,6 @@ +#[allow(unused_imports)] +use log::info; + use crate::util::{Plural, Required}; use toml::Value; @@ -33,7 +36,7 @@ impl ForeachExpanding for toml::map::Map { fn expand_foreach_value(&self, var: &str, value: &str) -> Self { let mut result = toml::map::Map::new(); for (k, v) in self { - result[k] = v.expand_foreach_value(var, value); + result.insert(k.clone(), v.expand_foreach_value(var, value)); } return result; } @@ -69,3 +72,16 @@ impl ForeachExpanding for String { return self.replace(&format!("{}{var}{}", "{{", "}}"), value); } } + +pub trait ForeachInterpolated { + fn foreach_interpolation(&self) -> String; +} + +impl ForeachInterpolated for Value { + fn foreach_interpolation(&self) -> String { + match self { + Value::String(str) => str.clone(), + _ => format!("{}", self), + } + } +} diff --git a/src/rust/parsing/src/command/mod.rs b/src/rust/parsing/src/command/mod.rs index daf9ba97..2c3a0c3d 100644 --- a/src/rust/parsing/src/command/mod.rs +++ b/src/rust/parsing/src/command/mod.rs @@ -1,13 +1,15 @@ #![allow(non_snake_case)] +mod constraints; mod foreach; mod validation; -use crate::command::foreach::ForeachExpanding; +use crate::command::foreach::{ForeachExpanding, ForeachInterpolated}; use crate::command::validation::{valid_json_array_object, valid_json_object, valid_key_binding}; use crate::error::{Error, Result}; use crate::util::{Merging, Plural, Required, Requiring}; +#[allow(unused_imports)] use log::info; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; @@ -47,7 +49,7 @@ fn default_mode() -> Plural { * a `*`. * */ -#[derive(Deserialize, Validate, Clone)] +#[derive(Deserialize, Validate, Clone, Debug)] pub struct CommandInput { /** * @forBindingField bind @@ -161,7 +163,7 @@ pub struct CommandInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - finalKey: Option, + finalKey: DefaultTrue, /** * @forBindingField bind @@ -320,7 +322,7 @@ impl CommandInput { } fn expand_foreach(&mut self) -> Result> { - let mut result = vec![]; + let mut result = vec![self.clone()]; while self.has_foreach() { result = self.expand_foreach_once(&result)?; } @@ -343,7 +345,7 @@ impl CommandInput { let mut result = Vec::with_capacity(inputs.len() * items.len()); for input in inputs { for value in items { - let str = format!("{}", value); + let str = value.foreach_interpolation(); result.push(input.expand_foreach_value(var, &str)); } } @@ -631,33 +633,39 @@ mod tests { assert_eq!(left.args, expected.args); } - // #[test] - // fn expands_foreach() { - // let data = r#" - // foreach.a = [1, 2] - // foreach.b = ["x", "y"] - // name = "test {{a}}-{{b}}" - // command = "run-{{a}}" - // args.value = "with-{{b}}" - // "#; - - // let mut result = toml::from_str::(data).unwrap(); - // let items = result.expand_foreach().unwrap(); - - // let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; - // let expected_value = vec!["with-x", "with-y", "witih-x", "with-y"]; - // let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; - - // for i in 0..4 { - // let item = items[i].clone(); - // assert_eq!(item.command.unwrap().as_str(), expected_command[i]); - // assert_eq!(item.name.unwrap().as_str(), expected_name[i]); - // assert_eq!( - // item.args.unwrap().get("value").unwrap().as_str().unwrap(), - // expected_value[i] - // ); - // } - // } + #[test] + fn expands_foreach() { + let data = r#" + foreach.a = [1, 2] + foreach.b = ["x", "y"] + name = "test {{a}}-{{b}}" + command = "run-{{a}}" + args.value = "with-{{b}}" + "#; + + let mut result = toml::from_str::(data).unwrap(); + let items = result.expand_foreach().unwrap(); + + let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; + let expected_value = vec!["with-x", "with-y", "with-x", "with-y"]; + let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; + + for i in 0..4 { + let item = items[i].clone(); + assert_eq!(item.command.unwrap().as_str(), expected_command[i]); + assert_eq!(item.name.unwrap().as_str(), expected_name[i]); + assert_eq!( + item.args.unwrap().get("value").unwrap().as_str().unwrap(), + expected_value[i] + ); + } + } + + // TODO: are there any edge cases / failure modes I want to look at in the tests + // (most of the things seem likely to be covered by serde / toml parsing, and the + // stuff I would want to check should be done at a higher level when I'm working + // through default resolution across multiple commands rather than the within + // command tests I'm working on here) } // TODO: define the "output" type for `Command` that can actually be passed to javascript diff --git a/src/rust/parsing/src/command/validation.rs b/src/rust/parsing/src/command/validation.rs index c1570d42..d2eaa57b 100644 --- a/src/rust/parsing/src/command/validation.rs +++ b/src/rust/parsing/src/command/validation.rs @@ -1,4 +1,4 @@ -use crate::util::Required; +use crate::{command::CommandInput, util::Required}; use lazy_static::lazy_static; use regex::Regex; use toml::Value; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index c53054ec..6416134a 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -2,16 +2,57 @@ use thiserror::Error; #[derive(Debug, Error)] pub enum Error { - #[error("Parsing Error: {0}")] + #[error("parsing failed with {0}")] Parsing(#[from] toml::de::Error), - #[error("Validation Error: {0}")] + #[error("validation failed with {0}")] Validation(#[from] validator::ValidationError), - #[error("Unexpected error binding rust values to javascript: {0}")] + #[error("expected {0}")] + ConstraintError(&'static str), + #[error("expected error binding rust values to javascript - {0}")] JavaScriptError(#[from] serde_wasm_bindgen::Error), - #[error("Missing required field `{0}`")] + #[error("required field `{0}`")] RequiredField(&'static str), - #[error("Unexpected error: {0}")] + #[error("unexpected {0}")] Unexpected(&'static str), } +pub trait Constrainable { + fn constrain(self, context: &'static str) -> Result; +} + +impl Constrainable for Option { + fn constrain(self, context: &'static str) -> Result { + return match self { + None => Err(Error::ConstraintError(context)), + Some(result) => Ok(result), + }; + } +} + +pub trait ConstrainArray { + fn constrain_array(self, context: &'static str) -> Result; +} + +impl ConstrainArray> for toml::Value { + fn constrain_array(self, context: &'static str) -> Result> { + return match self { + toml::Value::Array(items) => Ok(items), + _ => Err(Error::ConstraintError(context)), + }; + } +} + +pub trait ConstraintString { + fn constrain_string(self, context: &'static str) -> Result; +} + +impl ConstraintString for toml::Value { + fn constrain_string(self, context: &'static str) -> Result { + return match self { + toml::Value::String(x) => Ok(x), + _ => Err(Error::ConstraintError(context)), + }; + } +} + pub type Result = std::result::Result; From 860a44a0cfffcb36d8c65fcaacd81ebb705fb97c Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 20 Jul 2025 23:45:40 -0400 Subject: [PATCH 11/79] wip error handling refactor and foreach key expansion Created using spr 1.3.6-beta.1 --- mise.toml | 2 +- notes.md | 20 +- src/rust/parsing/Cargo.lock | 37 ++-- src/rust/parsing/Cargo.toml | 2 +- src/rust/parsing/src/command/constraints.rs | 39 ++-- src/rust/parsing/src/command/foreach.rs | 226 +++++++++++++++++++- src/rust/parsing/src/command/mod.rs | 54 ++++- src/rust/parsing/src/command/validation.rs | 2 +- src/rust/parsing/src/error.rs | 81 ++++--- src/rust/parsing/src/util.rs | 2 +- 10 files changed, 380 insertions(+), 85 deletions(-) diff --git a/mise.toml b/mise.toml index 208c9c9e..0b37d62f 100644 --- a/mise.toml +++ b/mise.toml @@ -88,7 +88,7 @@ run = 'tsc -p src/test --outDir out/test' depends = ['build-tests'] shell = 'nu -c' run = ''' -if ($env.COVERAGE? | into bool) { +if ($env.COVERAGE? | default false | into bool) { (pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath . --version insiders --coverage --coverage-output coverage/unit --coverage-reporter json) diff --git a/notes.md b/notes.md index 70b18997..072aa623 100644 --- a/notes.md +++ b/notes.md @@ -77,17 +77,21 @@ Integration test debugging: nightly tool-chain with - [X] rustup toolchain install nightly - [X] foreach expansion (unit tests remain) - - [ ] use DeTable instead of Table so we can generate more precise errors - - [ ] validation that `master-key.prefix` uses `finalKey: false` - - [ ] expand keys in `foreach` - - [ ] validation that keybindings with non modifier keybindings - have a condition requiring textEditorFocus + - [X] expand keys in `foreach` lists - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region - [ ] validate by checking error reporting NOTE: short term goal here is to support literate docs - [ ] pipeline for `[[bind]]` entries - [ ] basic pipeline - [ ] proper parsing with `[[default]]` and `defaults` + - [ ] foreach expansion + - [ ] command normalization (always `runCommand` with an array of objects with `command` field) + - [ ] check constraints + - [ ] validation that `master-key.prefix` uses `finalKey: false` + - [ ] validation that keybindings with non modifier keybindings + have a condition requiring textEditorFocus + - [ ] modes are all positive or negative + - [ ] required keys are present - [ ] mode expansion - [ ] documentation expandsion/validation across all `[[bind]]` values with the same key and mode @@ -136,6 +140,12 @@ Integration test debugging: 8. Migration of selection utilities to the same build and test setup 9. Generate detailed error reports for keybinding files and get them to show up in VSCode's problem window / linting underlines + - [ ] we need to let TOML language server know about the schema... + - [ ] https://github.com/GREsau/schemars to export schema + - [ ] insert '$schema' key into file + - [ ] use `document.positionAt` to convert spans byte offsets to char and line + - [ ] https://code.visualstudio.com/api/references/vscode-api#languages + look for `createDiagnosticsCollection` to create new linting hints 10. Translate selection utility tests to new build setup 11. Get CI working for all tests in selection utilities 12. continue the quest for better test coverage diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 9ca5a7e2..16eb9b75 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -599,9 +599,9 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "0.6.9" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3" +checksum = "40734c41988f7306bb04f0ecf60ec0f3f1caa34290e4e8ea471dcd3346483b83" dependencies = [ "serde", ] @@ -718,44 +718,42 @@ dependencies = [ [[package]] name = "toml" -version = "0.8.23" +version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362" +checksum = "ed0aee96c12fa71097902e0bb061a5e1ebd766a6636bb605ba401c45c1650eac" dependencies = [ + "indexmap", "serde", "serde_spanned", "toml_datetime", - "toml_edit", + "toml_parser", + "toml_writer", + "winnow", ] [[package]] name = "toml_datetime" -version = "0.6.11" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c" +checksum = "bade1c3e902f58d73d3f294cd7f20391c1cb2fbcb643b73566bc773971df91e3" dependencies = [ "serde", ] [[package]] -name = "toml_edit" -version = "0.22.27" +name = "toml_parser" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a" +checksum = "97200572db069e74c512a14117b296ba0a80a30123fbbb5aa1f4a348f639ca30" dependencies = [ - "indexmap", - "serde", - "serde_spanned", - "toml_datetime", - "toml_write", "winnow", ] [[package]] -name = "toml_write" -version = "0.1.2" +name = "toml_writer" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801" +checksum = "fcc842091f2def52017664b53082ecbbeb5c7731092bad69d2c63050401dfd64" [[package]] name = "tracing" @@ -1028,9 +1026,6 @@ name = "winnow" version = "0.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd" -dependencies = [ - "memchr", -] [[package]] name = "writeable" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index b1651def..f158c729 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -12,7 +12,7 @@ serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" test-log = "0.2.18" thiserror = "2.0.12" -toml = "0.8.23" +toml = "0.9.2" validator = { version = "0.20.0", features = ["derive"] } wasm-bindgen = "0.2.100" diff --git a/src/rust/parsing/src/command/constraints.rs b/src/rust/parsing/src/command/constraints.rs index 071130ae..80a900c1 100644 --- a/src/rust/parsing/src/command/constraints.rs +++ b/src/rust/parsing/src/command/constraints.rs @@ -2,35 +2,38 @@ // keybinding file has already been fully parsed use crate::command::CommandInput; -use crate::error::{ConstrainArray, Constrainable, ConstraintString, Error, Result}; +use crate::error::{Error, Result, constrain}; use crate::util::Requiring; -fn prefix_is_not_final_key(val: &CommandInput) -> Result<()> { - if val.finalKey.unwrap_or(|| true) { - let command = val.command.require("command")?; +// TODO: change this and test it *after* writing the other bits of the pipeline +pub fn prefix_is_not_final_key(val: &CommandInput) -> Result<()> { + if val.finalKey.unwrap_or(true) { + let command = val.command.clone().require("command")?; if command == "master-key.prefix" { - return Err(Error::ConstraintError( - "`mater-key.prefix` commands to include `finalKey = false` in their bindings", - )); + return constrain("`finalKey == false` when calling command `mater-key.prefix`"); } else if command == "runCommands" { let commands = val .args - .constrain("`runCommands` to have `args` field")? - .get("commands") - .constrain("`runCommands.args` to have `commands` field")? - .constrain_array("`commands` to be an array")?; + .as_ref() + .map(|x| x.get("commands")) + .flatten() + .map(|x| x.as_array()) + .unwrap_or_default(); - for command in commands { + for command in commands.into_iter().flatten() { let command_name = command .get("command") - .constrain("`command` field in `args.commands` of `runCommands`")? - .constrain_string("`command` field to be a string")?; + // while there are other valid forms for `args.commands` to take they + // can all be normalized (before this function call) to take on this + // format + .expect("`runCommands` `args.commands` elements to have `command` field") + .as_str() + .unwrap_or_default(); if command_name == "master-key.prefix" { - return Err(Error::ConstraintError( - "`mater-key.prefix` commands to include `finalKey = \ - false` in their bindings", - )); + return constrain( + "`finalKey == false` when calling command `mater-key.prefix`", + ); } } } diff --git a/src/rust/parsing/src/command/foreach.rs b/src/rust/parsing/src/command/foreach.rs index badd798c..79ed0480 100644 --- a/src/rust/parsing/src/command/foreach.rs +++ b/src/rust/parsing/src/command/foreach.rs @@ -1,7 +1,10 @@ +use crate::error::Result; +use crate::util::{Plural, Required}; + +use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; - -use crate::util::{Plural, Required}; +use regex::Regex; use toml::Value; pub trait ForeachExpanding { @@ -85,3 +88,222 @@ impl ForeachInterpolated for Value { } } } + +const ALL_KEYS: [&'static str; 192] = [ + "f0", + "f1", + "f2", + "f3", + "f4", + "f5", + "f6", + "f7", + "f8", + "f9", + "f10", + "f11", + "f12", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "`", + "-", + "=", + "[", + "]", + "\\", + ";", + "\"", + ",", + ".", + "/", + "left", + "up", + "right", + "down", + "pageup", + "pagedown", + "end", + "home", + "tab", + "enter", + "escape", + "space", + "backspace", + "delete", + "pausebreak", + "capslock", + "insert", + "numpad0", + "numpad1", + "numpad2", + "numpad3", + "numpad4", + "numpad5", + "numpad6", + "numpad7", + "numpad8", + "numpad9", + "numpad_multiply", + "numpad_add", + "numpad_separator", + "numpad_subtract", + "numpad_decimal", + "numpad_divide", + "[F1]", + "[F2]", + "[F3]", + "[F4]", + "[F5]", + "[F6]", + "[F7]", + "[F8]", + "[F9]", + "[F10]", + "[F11]", + "[F12]", + "[F13]", + "[F14]", + "[F15]", + "[F16]", + "[F17]", + "[F18]", + "[F19]", + "[KeyA]", + "[KeyB]", + "[KeyC]", + "[KeyD]", + "[KeyE]", + "[KeyF]", + "[KeyG]", + "[KeyH]", + "[KeyI]", + "[KeyJ]", + "[KeyK]", + "[KeyL]", + "[KeyM]", + "[KeyN]", + "[KeyO]", + "[KeyP]", + "[KeyQ]", + "[KeyR]", + "[KeyS]", + "[KeyT]", + "[KeyU]", + "[KeyV]", + "[KeyW]", + "[KeyX]", + "[KeyY]", + "[KeyZ]", + "[Digit0]", + "[Digit1]", + "[Digit2]", + "[Digit3]", + "[Digit4]", + "[Digit5]", + "[Digit6]", + "[Digit7]", + "[Digit8]", + "[Digit9]", + "[Backquote]", + "[Minus]", + "[Equal]", + "[BracketLeft]", + "[BracketRight]", + "[Backslash]", + "[Semicolon]", + "[Quote]", + "[Comma]", + "[Period]", + "[Slash]", + "[ArrowLeft]", + "[ArrowUp]", + "[ArrowRight]", + "[ArrowDown]", + "[PageUp]", + "[PageDown]", + "[End]", + "[Home]", + "[Tab]", + "[Enter]", + "[Escape]", + "[Space]", + "[Backspace]", + "[Delete]", + "[Pause]", + "[CapsLock]", + "[Insert]", + "[Numpad0]", + "[Numpad1]", + "[Numpad2]", + "[Numpad3]", + "[Numpad4]", + "[Numpad5]", + "[Numpad6]", + "[Numpad7]", + "[Numpad8]", + "[Numpad9]", + "[NumpadMultiply]", + "[NumpadAdd]", + "[NumpadComma]", + "[NumpadSubtract]", + "[NumpadDecimal]", + "[NumpadDivide]", +]; + +lazy_static! { + static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"\{\{key:\s*(.*)\}\}").unwrap(); +} + +pub fn expand_keys(items: &Vec) -> Result> { + let mut result = Vec::new(); + + for item in items { + if let Value::String(str_item) = item { + if let Some(caps) = KEY_PATTERN_REGEX.captures(&str_item) { + let key_regex = Regex::new(&caps[1])?; + for key in ALL_KEYS { + if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { + result.push(Value::String(key.into())); + } + } + continue; + } + } + result.push(item.clone()); + } + return Ok(result); +} diff --git a/src/rust/parsing/src/command/mod.rs b/src/rust/parsing/src/command/mod.rs index 2c3a0c3d..1c872f09 100644 --- a/src/rust/parsing/src/command/mod.rs +++ b/src/rust/parsing/src/command/mod.rs @@ -4,9 +4,9 @@ mod constraints; mod foreach; mod validation; -use crate::command::foreach::{ForeachExpanding, ForeachInterpolated}; +use crate::command::foreach::{ForeachExpanding, ForeachInterpolated, expand_keys}; use crate::command::validation::{valid_json_array_object, valid_json_object, valid_key_binding}; -use crate::error::{Error, Result}; +use crate::error::{Error, Result, unexpected}; use crate::util::{Merging, Plural, Required, Requiring}; #[allow(unused_imports)] @@ -163,7 +163,7 @@ pub struct CommandInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - finalKey: DefaultTrue, + finalKey: Option, /** * @forBindingField bind @@ -258,7 +258,7 @@ pub struct CommandInput { whenComputed: Option, } -impl Merging for CommandInput { +impl<'a> Merging for CommandInput { fn merge(self, y: Self) -> Self { CommandInput { command: y.command.or(self.command), @@ -342,9 +342,12 @@ impl CommandInput { final_foreach.remove(var); if let Value::Array(items) = values { - let mut result = Vec::with_capacity(inputs.len() * items.len()); + info!("{items:?}"); + let expanded_items = expand_keys(items)?; + info!("{expanded_items:?}"); + let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); for input in inputs { - for value in items { + for value in &expanded_items { let str = value.foreach_interpolation(); result.push(input.expand_foreach_value(var, &str)); } @@ -352,9 +355,7 @@ impl CommandInput { self.foreach = Some(final_foreach); return Ok(result); } else { - return Err(Error::Unexpected( - "`foreach` was expected to be a key of arrays.`", - )); + return unexpected("`foreach` was not an object of arrays"); } } else { return Ok(vec![]); @@ -392,7 +393,7 @@ impl CommandInput { impl Command { pub fn new(input: CommandInput) -> Result { if let Some(_) = input.foreach { - return Err(Error::Unexpected("`foreach` remains unresolved")); + return unexpected("`foreach` with unresolved variables"); } let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return Ok(Command { @@ -661,6 +662,39 @@ mod tests { } } + #[test] + fn expand_foreach_keys() { + let data = r#" + foreach.key = ["{{key: [0-9}}"] + name = "update {{key}}" + command = "foo" + args.value = "{{key}}" + "#; + + let mut result = toml::from_str::(data).unwrap(); + let items = result.expand_foreach().unwrap(); + + let expected_name: Vec = + (0..9).into_iter().map(|n| format!("update {n}")).collect(); + let expected_value: Vec = (0..9).into_iter().map(|n| format!("{}", n)).collect(); + + assert_eq!(items.len(), 10); + for i in 0..9 { + assert_eq!(items[i].name.as_ref().unwrap(), &expected_name[i]); + assert_eq!( + items[i] + .args + .as_ref() + .unwrap() + .get("value") + .unwrap() + .as_str() + .unwrap(), + expected_value[i] + ) + } + } + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/command/validation.rs b/src/rust/parsing/src/command/validation.rs index d2eaa57b..c1570d42 100644 --- a/src/rust/parsing/src/command/validation.rs +++ b/src/rust/parsing/src/command/validation.rs @@ -1,4 +1,4 @@ -use crate::{command::CommandInput, util::Required}; +use crate::util::Required; use lazy_static::lazy_static; use regex::Regex; use toml::Value; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 6416134a..dea66295 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,58 +1,89 @@ +use std::fmt; use thiserror::Error; +// TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) + #[derive(Debug, Error)] pub enum Error { - #[error("parsing failed with {0}")] + #[error("parsing {0}")] Parsing(#[from] toml::de::Error), - #[error("validation failed with {0}")] + #[error("validating {0}")] Validation(#[from] validator::ValidationError), #[error("expected {0}")] ConstraintError(&'static str), - #[error("expected error binding rust values to javascript - {0}")] + #[error("unexpected error binding rust values to javascript - {0}")] JavaScriptError(#[from] serde_wasm_bindgen::Error), #[error("required field `{0}`")] RequiredField(&'static str), #[error("unexpected {0}")] Unexpected(&'static str), + #[error("parsing regex failed with {0}")] + Regex(#[from] regex::Error), } -pub trait Constrainable { - fn constrain(self, context: &'static str) -> Result; +#[derive(Debug, Error)] +pub struct ErrorWithContext { + #[source] + error: Error, + contexts: Vec<&'static str>, } -impl Constrainable for Option { - fn constrain(self, context: &'static str) -> Result { - return match self { - None => Err(Error::ConstraintError(context)), - Some(result) => Ok(result), +impl fmt::Display for ErrorWithContext { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { + for context in &self.contexts { + write!(f, "{}\n", context); + } + self.error.fmt(f); + return Ok(()); + } +} + +impl> From for ErrorWithContext { + fn from(error: E) -> Self { + return ErrorWithContext { + error: error.into(), + contexts: vec![], }; } } -pub trait ConstrainArray { - fn constrain_array(self, context: &'static str) -> Result; +pub fn constrain(msg: &'static str) -> Result { + return Err(Error::ConstraintError(msg))?; } -impl ConstrainArray> for toml::Value { - fn constrain_array(self, context: &'static str) -> Result> { +pub fn unexpected(msg: &'static str) -> Result { + return Err(Error::Unexpected(msg))?; +} + +pub trait ErrorContext { + fn context(self, context: &'static str) -> Result; +} + +impl> ErrorContext for std::result::Result { + fn context(self, context: &'static str) -> Result { return match self { - toml::Value::Array(items) => Ok(items), - _ => Err(Error::ConstraintError(context)), + Ok(x) => Ok(x), + Err(e) => Err(ErrorWithContext { + error: e.into(), + contexts: vec![context], + }), }; } } -pub trait ConstraintString { - fn constrain_string(self, context: &'static str) -> Result; -} - -impl ConstraintString for toml::Value { - fn constrain_string(self, context: &'static str) -> Result { +impl ErrorContext for Result { + fn context(self, context: &'static str) -> Result { return match self { - toml::Value::String(x) => Ok(x), - _ => Err(Error::ConstraintError(context)), + Ok(x) => Ok(x), + Err(mut e) => { + e.contexts.push(context); + Err(ErrorWithContext { + error: e.error, + contexts: e.contexts, + }) + } }; } } -pub type Result = std::result::Result; +pub type Result = std::result::Result; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index a30317c4..03e368a2 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -45,7 +45,7 @@ pub enum Required { impl Requiring for Required { fn require(self, name: &'static str) -> Result { return match self { - Required::DefaultValue => Err(Error::RequiredField(name)), + Required::DefaultValue => Err(Error::RequiredField(name).into()), Required::Value(val) => Ok(val), }; } From 402e111cf2b47579e51e6dce50675589f129095c Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 25 Jul 2025 20:54:22 -0400 Subject: [PATCH 12/79] wip refactoring to handle span information Created using spr 1.3.6-beta.1 --- .gitignore | 2 + .vscode/settings.json | 28 ++ notes.md | 14 + src/rust/parsing/Cargo.lock | 1 + src/rust/parsing/Cargo.toml | 1 + .../parsing/src/{command/mod.rs => bind.rs} | 435 +++++++++++------- .../parsing/src/{command => bind}/foreach.rs | 8 +- .../src/{command => bind}/validation.rs | 40 +- src/rust/parsing/src/command/constraints.rs | 42 -- src/rust/parsing/src/error.rs | 31 +- src/rust/parsing/src/lib.rs | 2 +- src/rust/parsing/src/util.rs | 163 ++++++- 12 files changed, 514 insertions(+), 253 deletions(-) create mode 100644 .vscode/settings.json rename src/rust/parsing/src/{command/mod.rs => bind.rs} (58%) rename src/rust/parsing/src/{command => bind}/foreach.rs (95%) rename src/rust/parsing/src/{command => bind}/validation.rs (83%) delete mode 100644 src/rust/parsing/src/command/constraints.rs diff --git a/.gitignore b/.gitignore index 20c52b0a..b66b4285 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +!.vscode/settings.json + # build output out *.vsix diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..c2bacb02 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,28 @@ +{ + "rust-analyzer.linkedProjects": [ + "src/rust/parsing/Cargo.toml" + ], + "workbench.colorCustomizations": { + "editorBracketHighlight.foreground1": "#1b9e77", + "editorBracketHighlight.foreground2": "#d95f02", + "editorBracketHighlight.foreground3": "#7570b3", + "editorBracketHighlight.foreground4": "#e7298a", + "editorBracketHighlight.foreground5": "#66a61e", + "editorBracketHighlight.foreground6": "#e6ab02", + "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", + "titleBar.activeBackground": "#7279f9", + "titleBar.activeForeground": "#000000", + "titleBar.inactiveBackground": "#7279f9", + "titleBar.inactiveForeground": "#000000", + "titleBar.border": "#7279f9", + "activityBar.background": "#7279f9", + "activityBar.foreground": "#000000", + "statusBar.background": "#7279f9", + "statusBar.foreground": "#000000", + "statusBar.debuggingBackground": "#7279f9", + "statusBar.debuggingForeground": "#000000", + "tab.activeBorder": "#7279f9", + "iLoveWorkSpaceColors": true, + "iLoveWorkSpaceRandom": false + } +} diff --git a/notes.md b/notes.md index 072aa623..14d25c67 100644 --- a/notes.md +++ b/notes.md @@ -1,3 +1,4 @@ +validation.rs(11, 99): consider introducing a `where` clause, but there might be an alternative better way to express this requirement: ` where &toml::map::Map: From<&T>` Next steps: **TODO**: set up start and stop for tasks.json @@ -78,6 +79,19 @@ Integration test debugging: - [X] rustup toolchain install nightly - [X] foreach expansion (unit tests remain) - [X] expand keys in `foreach` lists + - [ ] include `Spanned` in fields of `BindInput` + - [ ] remove `computedArgs` and related functionality + and replace with more generic "{{value}}" replacement + (permitting the injection of e.g. objects, not just strings) + this can replace `[[default]]` and `default` elements as well + NOTE: internally we still use `computedArgs` in the binding + object `Binding`---it's only removed for `BindingInput`--- + this ensures a fast path for commands that don't have a computed argument + and limits the time to search and replace commands during binding + execution + TODO: we'll need to check for any remaining `{{}}` arguments + once `foreach` gets expanded and `computedArgs` gets completed + - [ ] format error messages appropriately - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region - [ ] validate by checking error reporting NOTE: short term goal here is to support literate docs diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 16eb9b75..c976feb2 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -410,6 +410,7 @@ name = "parsing" version = "0.1.0" dependencies = [ "env_logger", + "js-sys", "lazy_static", "log", "regex", diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index f158c729..5d74e5a8 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" [dependencies] env_logger = "0.11.8" +js-sys = "0.3.77" lazy_static = "1.5.0" log = { version = "0.4.27", features = ["release_max_level_error"] } regex = "1.11.1" diff --git a/src/rust/parsing/src/command/mod.rs b/src/rust/parsing/src/bind.rs similarity index 58% rename from src/rust/parsing/src/command/mod.rs rename to src/rust/parsing/src/bind.rs index 1c872f09..7902326f 100644 --- a/src/rust/parsing/src/command/mod.rs +++ b/src/rust/parsing/src/bind.rs @@ -1,33 +1,43 @@ #![allow(non_snake_case)] -mod constraints; mod foreach; mod validation; -use crate::command::foreach::{ForeachExpanding, ForeachInterpolated, expand_keys}; -use crate::command::validation::{valid_json_array_object, valid_json_object, valid_key_binding}; -use crate::error::{Error, Result, unexpected}; -use crate::util::{Merging, Plural, Required, Requiring}; +use crate::bind::foreach::{ForeachExpanding, ForeachInterpolated, expand_keys}; +use crate::bind::validation::{JsonObjectShape, valid_json_array_object, valid_key_binding}; +use crate::error::{Context, ErrorContext, Result, constrain, unexpected}; +use crate::util::{Merging, Plural, Required, Requiring, Resolving}; +use js_sys::Intl::PluralRules; +use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; -use toml::Value; +use toml::{Spanned, Value}; use validator::Validate; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; #[wasm_bindgen] -pub fn debug_parse_command(command_str: &str) -> std::result::Result { - let result = toml::from_str::(command_str)?; - return Ok(Command::new(result)?); +pub fn debug_parse_command(command_str: &str) -> std::result::Result { + let result = toml::from_str::(command_str)?; + return Ok(Binding::new(result)?); } -fn default_mode() -> Plural { - return Plural::One("default".into()); +pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; + +fn default_mode() -> Spanned> { + return Spanned::new(UNKNOWN_RANGE, Plural::One("default".into())); +} + +fn span_required_default() -> Spanned> { + return Spanned::new(UNKNOWN_RANGE, Required::DefaultValue); } +fn span_plural_default() -> Spanned> { + return Spanned::new(UNKNOWN_RANGE, Plural::Zero); +} /** * @bindingField bind * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` @@ -50,7 +60,7 @@ fn default_mode() -> Plural { * */ #[derive(Deserialize, Validate, Clone, Debug)] -pub struct CommandInput { +pub struct BindingInput { /** * @forBindingField bind * @@ -60,8 +70,8 @@ pub struct CommandInput { * behavior for the command `runCommands` * (see [running multiple commands](#running-multiple-commands)). */ - #[serde(default)] - command: Required, + #[serde(default = "span_required_default")] + command: Spanned>, /** * @forBindingField bind @@ -69,9 +79,9 @@ pub struct CommandInput { * - `args`: The arguments to directly pass to the `command`, these are static * values. */ - #[validate(custom(function = "valid_json_object"))] + #[validate(custom(function = "JsonObjectShape::valid_json_object"))] #[serde(default)] - args: Option, + args: Option>, /** * @forBindingField bind @@ -79,10 +89,10 @@ pub struct CommandInput { * - `computedArgs`: Like `args` except that each value is a string that is * evaluated as an [expression](/expressions/index). */ - // TODO: should be fieldds of strings not a general table (right??) - #[validate(custom(function = "valid_json_object"))] + // TODO: Spanned, + computedArgs: Option>, /** * @forBindingField bind @@ -91,9 +101,9 @@ pub struct CommandInput { * [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that * triggers `command`. */ - #[serde(default)] + #[serde(default = "span_required_default")] #[validate(custom(function = "valid_key_binding"))] - key: Required, + key: Spanned>, /** * @forBindingField bind * @@ -102,8 +112,8 @@ pub struct CommandInput { * context under which the binding will be active. Also see Master Key's * [available contexts](#available-contexts) */ - #[serde(default)] - when: Plural, + #[serde(default = "span_plural_default")] + when: Spanned>, /** * @forBindingField bind * @@ -113,7 +123,7 @@ pub struct CommandInput { * a binding that is applied in all modes use "{{all_modes}}". */ #[serde(default = "default_mode")] - mode: Plural, + mode: Spanned>, /** * @forBindingField bind * @@ -121,7 +131,7 @@ pub struct CommandInput { * bindings take precedence. Defaults to 0. */ #[serde(default)] - priority: Option, + priority: Option>, /** * @forBindingField bind * @@ -129,7 +139,7 @@ pub struct CommandInput { * [`default`](/bindings/default) for more details. */ #[serde(default)] - defaults: Option, + defaults: Option>, /** * @forBindingField bind * @@ -138,7 +148,7 @@ pub struct CommandInput { */ #[serde(default)] #[validate(custom(function = "valid_json_array_object"))] - foreach: Option, + foreach: Option>, /** * @forBindingField bind @@ -152,8 +162,8 @@ pub struct CommandInput { * sequence that has been pressed (e.g. this is used for the "escape" key binding * in Larkin). */ - #[serde(default)] - prefixes: Plural, + #[serde(default = "span_plural_default")] + prefixes: Spanned>, /** * @forBindingField bind @@ -163,7 +173,7 @@ pub struct CommandInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - finalKey: Option, + finalKey: Option>, /** * @forBindingField bind @@ -174,7 +184,7 @@ pub struct CommandInput { * - `command` will be repeated the given * number of times. */ - computedRepeat: Option, + computedRepeat: Option>, /** * @forBindingField bind @@ -190,7 +200,7 @@ pub struct CommandInput { * keys. Favor unicode symbols such as → and ← over text. */ #[serde(default)] - name: Option, + name: Option>, /** * @forBindingField bind @@ -201,7 +211,7 @@ pub struct CommandInput { * for the literate comments. */ #[serde(default)] - description: Option, + description: Option>, /** * @forBindingField bind * @order 10 @@ -210,9 +220,9 @@ pub struct CommandInput { * and the documentation. These both default to false. */ #[serde(default)] - hideInPalette: Option, + hideInPalette: Option>, #[serde(default)] - hideInDocs: Option, + hideInDocs: Option>, /** * @forBindingField bind @@ -226,11 +236,11 @@ pub struct CommandInput { * `combinedDescription` are ignored. */ #[serde(default)] - combinedName: Option, + combinedName: Option>, #[serde(default)] - combinedKey: Option, + combinedKey: Option>, #[serde(default)] - combinedDescription: Option, + combinedDescription: Option>, /** * @forBindingField bind @@ -241,58 +251,51 @@ pub struct CommandInput { * entry in the top-level `kind` array. */ #[serde(default)] - kind: Option, - /** - * @forBindingField bind - * @order 5 - * - * - `whenComputed`: an [expression](/expressions/index) that, if evaluated to - * false, the command will not execute. Favor `when` clauses over `whenComputed`. - * The `whenComputed` field is distinct from the `when` clause because it uses the - * scope of expressions rather than when clause statements. Furthermore, even if - * the `whenComputed` is false, the binding is still considered to have triggered, - * and now downstream keybindings will be triggered. It is most useful in - * conjunction with `runCommands` or [`storeCommand`](/commands/storeCommand). - */ - #[serde(default)] - whenComputed: Option, + kind: Option>, } -impl<'a> Merging for CommandInput { +impl Merging for BindingInput { + fn coalesce(self, new: Self) -> Self { + return new; + } fn merge(self, y: Self) -> Self { - CommandInput { - command: y.command.or(self.command), + BindingInput { + command: self.command.coalesce(y.command), args: self.args.merge(y.args), computedArgs: self.computedArgs.merge(y.computedArgs), - key: y.key.or(self.key), - when: y.when.or(self.when), - mode: y.mode.or(self.mode), - priority: y.priority.or(self.priority), - defaults: y.defaults.or(self.defaults), + key: self.key.coalesce(y.key), + when: self.when.coalesce(y.when), + mode: self.mode.coalesce(y.mode), + priority: self.priority.coalesce(y.priority), + defaults: self.defaults.coalesce(y.defaults), foreach: self.foreach, - prefixes: y.prefixes.or(self.prefixes), - finalKey: y.finalKey.or(self.finalKey), - computedRepeat: y.computedRepeat.or(self.computedRepeat), - name: y.name.or(self.name), - description: y.description.or(self.description), - hideInPalette: y.hideInPalette.or(self.hideInPalette), - hideInDocs: y.hideInDocs.or(self.hideInDocs), - combinedName: y.combinedName.or(self.combinedName), - combinedKey: y.combinedKey.or(self.combinedKey), - combinedDescription: y.combinedDescription.or(self.combinedDescription), - kind: y.kind.or(self.kind), - whenComputed: y.whenComputed.or(self.whenComputed), + prefixes: self.prefixes.coalesce(y.prefixes), + finalKey: self.finalKey.coalesce(y.finalKey), + computedRepeat: self.computedRepeat.coalesce(y.computedRepeat), + name: self.name.coalesce(y.name), + description: self.description.coalesce(y.description), + hideInPalette: self.hideInPalette.coalesce(y.hideInPalette), + hideInDocs: self.hideInDocs.coalesce(y.hideInDocs), + combinedName: self.combinedName.coalesce(y.combinedName), + combinedKey: self.combinedKey.coalesce(y.combinedKey), + combinedDescription: self.combinedDescription.coalesce(y.combinedDescription), + kind: self.kind.coalesce(y.kind), } } } #[wasm_bindgen(getter_with_clone)] -#[allow(non_snake_case)] +#[derive(Clone)] pub struct Command { pub command: String, pub args: JsValue, - pub computedArgs: JsValue, +} + +#[allow(non_snake_case)] +#[wasm_bindgen(getter_with_clone)] +pub struct Binding { pub key: String, + pub commands: Vec, pub when: Vec, pub mode: Vec, pub priority: i64, @@ -308,20 +311,19 @@ pub struct Command { pub combinedKey: Option, pub combinedDescription: Option, pub kind: Option, - pub whenComputed: Option, } // TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error -impl CommandInput { +impl BindingInput { fn has_foreach(&self) -> bool { if let Some(foreach) = &self.foreach { - return foreach.len() > 0; + return foreach.get_ref().len() > 0; } return false; } - fn expand_foreach(&mut self) -> Result> { + fn expand_foreach(&mut self) -> Result> { let mut result = vec![self.clone()]; while self.has_foreach() { result = self.expand_foreach_once(&result)?; @@ -329,9 +331,9 @@ impl CommandInput { return Ok(result); } - fn expand_foreach_once(&mut self, inputs: &Vec) -> Result> { + fn expand_foreach_once(&mut self, inputs: &Vec) -> Result> { let foreach = match &self.foreach { - Some(foreach) => foreach, + Some(foreach) => foreach.get_ref(), None => &toml::map::Map::new(), }; let mut final_foreach = foreach.clone(); @@ -342,9 +344,8 @@ impl CommandInput { final_foreach.remove(var); if let Value::Array(items) = values { - info!("{items:?}"); - let expanded_items = expand_keys(items)?; - info!("{expanded_items:?}"); + let expanded_items = expand_keys(items) + .context(Context::String(format!("while reading {}", values)))?; let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); for input in inputs { for value in &expanded_items { @@ -352,7 +353,7 @@ impl CommandInput { result.push(input.expand_foreach_value(var, &str)); } } - self.foreach = Some(final_foreach); + self.foreach = Some(Spanned::new(UNKNOWN_RANGE, final_foreach)); return Ok(result); } else { return unexpected("`foreach` was not an object of arrays"); @@ -363,66 +364,126 @@ impl CommandInput { } fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return CommandInput { + return BindingInput { command: self.command.expand_foreach_value(var, value), args: self.args.expand_foreach_value(var, value), computedArgs: self.computedArgs.expand_foreach_value(var, value), key: self.key.expand_foreach_value(var, value), when: self.when.expand_foreach_value(var, value), mode: self.mode.expand_foreach_value(var, value), - priority: self.priority, + priority: self.priority.clone(), defaults: self.defaults.expand_foreach_value(var, value), prefixes: self.prefixes.expand_foreach_value(var, value), - finalKey: self.finalKey, + finalKey: self.finalKey.clone(), computedRepeat: self.computedRepeat.expand_foreach_value(var, value), foreach: None, name: self.name.expand_foreach_value(var, value), description: self.description.expand_foreach_value(var, value), - hideInPalette: self.hideInPalette, - hideInDocs: self.hideInDocs, + hideInPalette: self.hideInPalette.clone(), + hideInDocs: self.hideInDocs.clone(), combinedName: self.combinedName.expand_foreach_value(var, value), combinedKey: self.combinedKey.expand_foreach_value(var, value), combinedDescription: self.combinedDescription.expand_foreach_value(var, value), kind: self.kind.expand_foreach_value(var, value), - whenComputed: self.whenComputed.expand_foreach_value(var, value), }; } } +fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec)> { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let command_pos = input.command.span(); + let command = input.command.get_ref().clone().resolve("command")?; + let args = input.args.clone(); + if command == "runCommands" { + let spanned = args + .require("`args`") + .context(Context::Range(command_pos)) + .context(Context::String( + "`runCommands` must have `args` field".into(), + ))?; + let args_pos = spanned.span(); + let args = spanned.into_inner(); + let commands = args + .get("commands") + .require("`commands`") + .context(Context::String( + "`runCommands.args` must have a `commands` fields".into(), + )) + .context(Context::Range(args_pos.clone()))?; + let commands = commands.as_array().require("`commands` to be an array")?; + let mut command_result = Vec::with_capacity(commands.len()); + for command in commands { + let (command, args) = match command { + Value::String(str) => (str.to_owned(), toml::Table::new()), + Value::Table(kv) => { + let command_name = kv + .get("command") + .require("`command`")? + .as_str() + .require("`command` to be string") + .context(Context::Range(args_pos.clone()))? + .to_owned(); + let args = command + .get("args") + .require("`args`")? + .as_table() + .require("`args` to be a table")? + .to_owned(); + (command_name, args) + } + _ => { + return constrain( + "`commands` to be an array that includes objects and strings only", + )?; + } + }; + + command_result.push(Command { + command, + args: args.serialize(&to_json)?, + }) + } + + return Ok((input, command_result)); + } else { + return Ok(( + input, + vec![Command { + command, + args: args.serialize(&to_json)?, + }], + )); + } +} + // TODO: think about whether I want to represent commands as a sequence in the output... -impl Command { - pub fn new(input: CommandInput) -> Result { +impl Binding { + pub fn new(input: BindingInput) -> Result { + serde_wasm_bindgen::Serializer::json_compatible(); if let Some(_) = input.foreach { return unexpected("`foreach` with unresolved variables"); } - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - return Ok(Command { - command: input.command.require("command")?, - args: input - .args - .unwrap_or_else(|| toml::Table::new()) - .serialize(&to_json)?, - computedArgs: input - .computedArgs - .unwrap_or_else(|| toml::Table::new()) - .serialize(&to_json)?, - key: input.key.require("key")?, - when: input.when.to_array(), - mode: input.mode.to_array(), - priority: input.priority.unwrap_or(0), - defaults: input.defaults.unwrap_or_default(), - prefixes: input.prefixes.to_array(), - finalKey: input.finalKey.unwrap_or_default(), - computedRepeat: input.computedRepeat, - name: input.name, - description: input.description, - hideInPalette: input.hideInPalette, - hideInDocs: input.hideInDocs, - combinedName: input.combinedName, - combinedKey: input.combinedKey, - combinedDescription: input.combinedDescription, - kind: input.kind, - whenComputed: input.whenComputed, + let (input, commands) = regularize_commands(input)?; + // TODO this is where we should validate that prefix has `finalKey == false` + + return Ok(Binding { + commands: commands, + key: input.key.into_inner().require("key")?, + when: input.when.into_inner().to_array(), + mode: input.mode.into_inner().to_array(), + priority: input.priority.map(|x| x.into_inner()).unwrap_or(0), + defaults: input.defaults.map(|x| x.into_inner()).unwrap_or_default(), + prefixes: input.prefixes.into_inner().to_array(), + finalKey: input.finalKey.map(|x| x.into_inner()).unwrap_or_default(), + computedRepeat: input.computedRepeat.map(|x| x.into_inner()), + name: input.name.map(|x| x.into_inner()), + description: input.description.map(|x| x.into_inner()), + hideInPalette: input.hideInPalette.map(|x| x.into_inner()), + hideInDocs: input.hideInDocs.map(|x| x.into_inner()), + combinedName: input.combinedName.map(|x| x.into_inner()), + combinedKey: input.combinedKey.map(|x| x.into_inner()), + combinedDescription: input.combinedDescription.map(|x| x.into_inner()), + kind: input.kind.clone().map(|x| x.into_inner()), }); } } @@ -456,39 +517,46 @@ mod tests { combinedKey = "A/B" combinedDescription = "bla bla bla" kind = "biz" - whenComputed = "f > 2" "#; - let result = toml::from_str::(data).unwrap(); + let result = toml::from_str::(data).unwrap(); - assert_eq!(result.command, Required::Value("do".into())); - let args = result.args.unwrap(); + assert_eq!(result.command.into_inner(), Required::Value("do".into())); + let args = result.args.unwrap().into_inner(); assert_eq!(args.get("a").unwrap(), &Value::String("2".into())); assert_eq!(args.get("b").unwrap(), &Value::Integer(3)); assert_eq!( - result.computedArgs.unwrap().get("c").unwrap(), + result.computedArgs.unwrap().into_inner().get("c").unwrap(), &Value::String("1+2".into()) ); - assert_eq!(result.key, Required::Value("a".into())); - assert_eq!(result.when, Plural::One("joe > 1".into())); - assert_eq!(result.mode, Plural::One("normal".into())); - assert_eq!(result.priority.unwrap(), 1); - assert_eq!(result.defaults.unwrap(), "foo.bar"); + assert_eq!(result.key.into_inner(), Required::Value("a".into())); + assert_eq!(result.when.into_inner(), Plural::One("joe > 1".into())); + assert_eq!(result.mode.into_inner(), Plural::One("normal".into())); + assert_eq!(result.priority.map(|x| x.into_inner()).unwrap(), 1); + assert_eq!(result.defaults.map(|x| x.into_inner()).unwrap(), "foo.bar"); assert_eq!( - result.foreach.unwrap().get("index").unwrap(), + result.foreach.unwrap().into_inner().get("index").unwrap(), &Value::Array(vec![1, 2, 3].iter().map(|x| Value::Integer(*x)).collect()) ); - assert_eq!(result.prefixes, Plural::One("c".into())); - assert_eq!(result.finalKey.unwrap(), true); - assert_eq!(result.name.unwrap(), "foo"); - assert_eq!(result.description.unwrap(), "foo bar bin"); - assert_eq!(result.hideInDocs.unwrap(), false); - assert_eq!(result.hideInPalette.unwrap(), false); - assert_eq!(result.combinedName.unwrap(), "Up/down"); - assert_eq!(result.combinedKey.unwrap(), "A/B"); - assert_eq!(result.combinedDescription.unwrap(), "bla bla bla"); - assert_eq!(result.kind.unwrap(), "biz"); - assert_eq!(result.whenComputed.unwrap(), "f > 2"); + assert_eq!(result.prefixes.into_inner(), Plural::One("c".into())); + assert_eq!(result.finalKey.map(|x| x.into_inner()).unwrap(), true); + assert_eq!(result.name.map(|x| x.into_inner()).unwrap(), "foo"); + assert_eq!( + result.description.map(|x| x.into_inner()).unwrap(), + "foo bar bin" + ); + assert_eq!(result.hideInDocs.map(|x| x.into_inner()).unwrap(), false); + assert_eq!(result.hideInPalette.map(|x| x.into_inner()).unwrap(), false); + assert_eq!( + result.combinedName.map(|x| x.into_inner()).unwrap(), + "Up/down" + ); + assert_eq!(result.combinedKey.map(|x| x.into_inner()).unwrap(), "A/B"); + assert_eq!( + result.combinedDescription.map(|x| x.into_inner()).unwrap(), + "bla bla bla" + ); + assert_eq!(result.kind.map(|x| x.into_inner()).unwrap(), "biz"); } #[test] @@ -499,15 +567,22 @@ mod tests { args.to = "left" "#; - let result = toml::from_str::(data).unwrap(); - assert_eq!(result.key.unwrap(), "l"); - assert_eq!(result.command.unwrap(), "cursorMove"); + let result = toml::from_str::(data).unwrap(); + assert_eq!(result.key.into_inner().unwrap(), "l"); + assert_eq!(result.command.into_inner().unwrap(), "cursorMove"); assert_eq!( - result.args.unwrap().get("to").unwrap().as_str().unwrap(), + result + .args + .unwrap() + .into_inner() + .get("to") + .unwrap() + .as_str() + .unwrap(), "left" ); - assert_eq!(result.when, Plural::Zero); + assert_eq!(result.when.into_inner(), Plural::Zero); assert_eq!(result.combinedDescription, None); assert_eq!(result.combinedName, None); } @@ -528,28 +603,38 @@ mod tests { prefixes = ["b", "c"] "#; - let result = toml::from_str::>>(data).unwrap(); + let result = toml::from_str::>>(data).unwrap(); let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let left = default.merge(left); - assert_eq!(left.key.unwrap(), "l"); - assert_eq!(left.command.unwrap(), "cursorMove"); + assert_eq!(left.key.into_inner().unwrap(), "l"); + assert_eq!(left.command.into_inner().unwrap(), "cursorMove"); assert_eq!( - left.args.unwrap().get("to").unwrap().as_str().unwrap(), + left.args + .unwrap() + .into_inner() + .get("to") + .unwrap() + .as_str() + .unwrap(), "left" ); assert_eq!( left.computedArgs .unwrap() + .into_inner() .get("value") .unwrap() .as_str() .unwrap(), "count" ); - assert_eq!(left.prefixes, Plural::Many(vec!["b".into(), "c".into()])); + assert_eq!( + left.prefixes.into_inner(), + Plural::Many(vec!["b".into(), "c".into()]) + ); - assert_eq!(left.when, Plural::Zero); + assert_eq!(left.when.into_inner(), Plural::Zero); assert_eq!(left.combinedDescription, None); assert_eq!(left.combinedName, None); } @@ -573,7 +658,7 @@ mod tests { args.foo = { a = 2, b = 3, c = { x = 1, y = 2 }, d = 12 } "#; - let result = toml::from_str::>>(data).unwrap(); + let result = toml::from_str::>>(data).unwrap(); let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let expected = result.get("bind").unwrap()[2].clone(); @@ -625,7 +710,7 @@ mod tests { args = {x = "biz", y = "fiz"} "#; - let result = toml::from_str::>>(data).unwrap(); + let result = toml::from_str::>>(data).unwrap(); let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let expected = result.get("bind").unwrap()[2].clone(); @@ -644,7 +729,7 @@ mod tests { args.value = "with-{{b}}" "#; - let mut result = toml::from_str::(data).unwrap(); + let mut result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; @@ -653,10 +738,19 @@ mod tests { for i in 0..4 { let item = items[i].clone(); - assert_eq!(item.command.unwrap().as_str(), expected_command[i]); - assert_eq!(item.name.unwrap().as_str(), expected_name[i]); assert_eq!( - item.args.unwrap().get("value").unwrap().as_str().unwrap(), + item.command.as_ref().clone().unwrap().as_str(), + expected_command[i] + ); + assert_eq!(item.name.unwrap().as_ref().as_str(), expected_name[i]); + assert_eq!( + item.args + .unwrap() + .as_ref() + .get("value") + .unwrap() + .as_str() + .unwrap(), expected_value[i] ); } @@ -665,13 +759,13 @@ mod tests { #[test] fn expand_foreach_keys() { let data = r#" - foreach.key = ["{{key: [0-9}}"] + foreach.key = ["{{key: [0-9]}}"] name = "update {{key}}" command = "foo" args.value = "{{key}}" "#; - let mut result = toml::from_str::(data).unwrap(); + let mut result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); let expected_name: Vec = @@ -680,18 +774,9 @@ mod tests { assert_eq!(items.len(), 10); for i in 0..9 { - assert_eq!(items[i].name.as_ref().unwrap(), &expected_name[i]); - assert_eq!( - items[i] - .args - .as_ref() - .unwrap() - .get("value") - .unwrap() - .as_str() - .unwrap(), - expected_value[i] - ) + assert_eq!(items[i].name.as_ref().unwrap().get_ref(), &expected_name[i]); + let value = items[i].args.as_ref().unwrap().get_ref().get("value"); + assert_eq!(value.unwrap().as_str().unwrap(), expected_value[i]); } } @@ -702,4 +787,4 @@ mod tests { // command tests I'm working on here) } -// TODO: define the "output" type for `Command` that can actually be passed to javascript +// TODO: define the "output" type for `Binding` that can actually be passed to javascript diff --git a/src/rust/parsing/src/command/foreach.rs b/src/rust/parsing/src/bind/foreach.rs similarity index 95% rename from src/rust/parsing/src/command/foreach.rs rename to src/rust/parsing/src/bind/foreach.rs index 79ed0480..d4c88a0b 100644 --- a/src/rust/parsing/src/command/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -5,12 +5,18 @@ use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use toml::Value; +use toml::{Spanned, Value}; pub trait ForeachExpanding { fn expand_foreach_value(&self, var: &str, value: &str) -> Self; } +impl ForeachExpanding for Spanned { + fn expand_foreach_value(&self, var: &str, value: &str) -> Self { + return Spanned::new(self.span(), self.get_ref().expand_foreach_value(var, value)); + } +} + impl ForeachExpanding for Plural { fn expand_foreach_value(&self, var: &str, value: &str) -> Self { match self { diff --git a/src/rust/parsing/src/command/validation.rs b/src/rust/parsing/src/bind/validation.rs similarity index 83% rename from src/rust/parsing/src/command/validation.rs rename to src/rust/parsing/src/bind/validation.rs index c1570d42..245a2502 100644 --- a/src/rust/parsing/src/command/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,15 +1,30 @@ use crate::util::Required; use lazy_static::lazy_static; use regex::Regex; -use toml::Value; +use toml::{Spanned, Value}; use validator::ValidationError; pub fn valid_json_array(values: &Vec) -> std::result::Result<(), ValidationError> { return values.iter().try_for_each(valid_json_value); } -pub fn valid_json_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { - return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); +pub trait JsonObjectShape { + fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError>; +} + +impl JsonObjectShape for toml::Table { + fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError> { + return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); + } +} + +impl JsonObjectShape for &Spanned { + fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError> { + return kv + .get_ref() + .iter() + .try_for_each(|(_, v)| valid_json_value(v)); + } } // we read in TOML values, but only want to accept JSON-valid values in some contexts @@ -23,12 +38,17 @@ pub fn valid_json_value(x: &Value) -> std::result::Result<(), ValidationError> { return Err(ValidationError::new("DateTime values are not supported")); } Value::Array(values) => return valid_json_array(values), - Value::Table(kv) => return valid_json_object(kv), + Value::Table(kv) => return toml::Table::valid_json_object(kv), }; } -pub fn valid_json_array_object(kv: &toml::Table) -> std::result::Result<(), ValidationError> { - return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); +pub fn valid_json_array_object( + kv: &Spanned, +) -> std::result::Result<(), ValidationError> { + return kv + .as_ref() + .iter() + .try_for_each(|(_, v)| valid_json_value(v)); } lazy_static! { @@ -116,11 +136,13 @@ lazy_static! { ]; } -pub fn valid_key_binding(val: &Required) -> std::result::Result<(), ValidationError> { - match val { +pub fn valid_key_binding( + val: &Spanned>, +) -> std::result::Result<(), ValidationError> { + match val.get_ref() { Required::DefaultValue => return Ok(()), Required::Value(x) => { - if valid_key_binding_str(&x) { + if valid_key_binding_str(x) { return Err(ValidationError::new("Invalid key binding")); } else { return Ok(()); diff --git a/src/rust/parsing/src/command/constraints.rs b/src/rust/parsing/src/command/constraints.rs deleted file mode 100644 index 80a900c1..00000000 --- a/src/rust/parsing/src/command/constraints.rs +++ /dev/null @@ -1,42 +0,0 @@ -// constraints are validate the global semantics of keybindings the can only occur once a -// keybinding file has already been fully parsed - -use crate::command::CommandInput; -use crate::error::{Error, Result, constrain}; -use crate::util::Requiring; - -// TODO: change this and test it *after* writing the other bits of the pipeline -pub fn prefix_is_not_final_key(val: &CommandInput) -> Result<()> { - if val.finalKey.unwrap_or(true) { - let command = val.command.clone().require("command")?; - if command == "master-key.prefix" { - return constrain("`finalKey == false` when calling command `mater-key.prefix`"); - } else if command == "runCommands" { - let commands = val - .args - .as_ref() - .map(|x| x.get("commands")) - .flatten() - .map(|x| x.as_array()) - .unwrap_or_default(); - - for command in commands.into_iter().flatten() { - let command_name = command - .get("command") - // while there are other valid forms for `args.commands` to take they - // can all be normalized (before this function call) to take on this - // format - .expect("`runCommands` `args.commands` elements to have `command` field") - .as_str() - .unwrap_or_default(); - - if command_name == "master-key.prefix" { - return constrain( - "`finalKey == false` when calling command `mater-key.prefix`", - ); - } - } - } - } - return Ok(()); -} diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index dea66295..7cdc6ec6 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,6 +1,9 @@ use std::fmt; use thiserror::Error; +use crate::bind::UNKNOWN_RANGE; +use core::ops::Range; + // TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) #[derive(Debug, Error)] @@ -13,7 +16,7 @@ pub enum Error { ConstraintError(&'static str), #[error("unexpected error binding rust values to javascript - {0}")] JavaScriptError(#[from] serde_wasm_bindgen::Error), - #[error("required field `{0}`")] + #[error("required {0}")] RequiredField(&'static str), #[error("unexpected {0}")] Unexpected(&'static str), @@ -25,13 +28,29 @@ pub enum Error { pub struct ErrorWithContext { #[source] error: Error, - contexts: Vec<&'static str>, + contexts: Vec, +} + +#[derive(Debug)] +pub enum Context { + String(String), + Range(Range), } impl fmt::Display for ErrorWithContext { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { for context in &self.contexts { - write!(f, "{}\n", context); + match context { + Context::String(str) => { + write!(f, "{}\n", str); + } + Context::Range(range) => { + // TODO: we may evenutally wan to support showing the text + // here. *HOWEVER* this is something we can also do downstream + // with the document class in vscode so probably not necessary + write!(f, "byte range {:?}\n", range); + } + } } self.error.fmt(f); return Ok(()); @@ -56,11 +75,11 @@ pub fn unexpected(msg: &'static str) -> Result { } pub trait ErrorContext { - fn context(self, context: &'static str) -> Result; + fn context(self, context: Context) -> Result; } impl> ErrorContext for std::result::Result { - fn context(self, context: &'static str) -> Result { + fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), Err(e) => Err(ErrorWithContext { @@ -72,7 +91,7 @@ impl> ErrorContext for std::result::Result { } impl ErrorContext for Result { - fn context(self, context: &'static str) -> Result { + fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), Err(mut e) => { diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index e3675af7..cf4d2d1a 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,4 +1,4 @@ -pub mod command; +pub mod bind; mod error; mod util; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 03e368a2..e4c14356 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,37 +1,117 @@ -use crate::error::{Error, Result}; +use crate::{ + bind::UNKNOWN_RANGE, + error::{Error, ErrorContext, Result}, +}; use log::info; use serde::{Deserialize, Serialize}; -use toml::Value; +use toml::{Spanned, Value}; pub trait Merging { fn merge(self, new: Self) -> Self; + fn coalesce(self, new: Self) -> Self; } +pub trait Resolving { + fn resolve(self, name: &'static str) -> Result; +} + pub trait Requiring { fn require(self, name: &'static str) -> Result; } // TODO: is there any way to avoid so much copying here impl Merging for toml::Table { - fn merge(self, new: Self) -> Self { - let mut result = new.clone(); + fn merge(self, mut new: Self) -> Self { for (k, v) in self { if new.contains_key(&k) { - result[&k] = v.merge(result[&k].clone()); + new[&k] = v.merge(new[&k].clone()); } else { - result.insert(k, v); + new.insert(k, v); } } - return result; + return new; + } + fn coalesce(self, new: Self) -> Self { + return new; + } +} + +impl Merging for Spanned { + fn merge(self, new: Self) -> Self { + return Spanned::new(self.span(), self.into_inner().merge(new.into_inner())); + } + fn coalesce(self, new: Self) -> Self { + return Spanned::new(self.span(), self.into_inner().coalesce(new.into_inner())); + } +} + +impl Merging for Required { + fn merge(self, new: Self) -> Self { + return match new { + Required::Value(newval) => match self { + Required::Value(oldval) => Required::Value(oldval.merge(newval)), + Required::DefaultValue => Required::Value(newval), + }, + Required::DefaultValue => self, + }; + } + + fn coalesce(self, new: Self) -> Self { + return match new { + Required::Value(_) => new, + Required::DefaultValue => self, + }; } } -impl Requiring> for Option { - fn require(self, _: &str) -> Result { +impl Merging for Plural { + fn merge(self, _: Self) -> Self { + panic!("Not yet implemented (we don't yet need this function)") + } + + fn coalesce(self, new: Self) -> Self { + return match new { + Plural::Zero => self, + _ => new, + }; + } +} + +impl Merging for i64 { + fn merge(self, new: Self) -> Self { + return new; + } + + fn coalesce(self, new: Self) -> Self { + return new; + } +} + +impl Merging for bool { + fn merge(self, new: Self) -> Self { + return new; + } + + fn coalesce(self, new: Self) -> Self { + return new; + } +} + +impl Resolving> for Option { + fn resolve(self, _name: &'static str) -> Result { return Ok(self); } } +impl Requiring for Option { + fn require(self, name: &'static str) -> Result { + match self { + Some(x) => Ok(x), + None => Err(Error::RequiredField(name).into()), + } + } +} + // required values are only required at the very end of parsing, once all known defaults // have been resolved #[derive(Default, Deserialize, Serialize, PartialEq, Debug, Clone)] @@ -42,8 +122,17 @@ pub enum Required { Value(T), } -impl Requiring for Required { - fn require(self, name: &'static str) -> Result { +impl Required> { + pub fn into_inner(self) -> Required { + return match self { + Required::DefaultValue => Required::DefaultValue, + Required::Value(val) => Required::Value(val.into_inner()), + }; + } +} + +impl Resolving for Required { + fn resolve(self, name: &'static str) -> Result { return match self { Required::DefaultValue => Err(Error::RequiredField(name).into()), Required::Value(val) => Ok(val), @@ -51,6 +140,12 @@ impl Requiring for Required { } } +impl Requiring for Required { + fn require(self, name: &'static str) -> Result { + return self.resolve(name); + } +} + impl Required { pub fn unwrap(self) -> T { return match self { @@ -79,14 +174,35 @@ pub enum Plural { Many(Vec), } -impl Plural { - pub fn to_array(self) -> Vec { +impl Plural> { + pub fn into_inner(self) -> Plural { + return match self { + Plural::Zero => Plural::Zero, + Plural::One(x) => Plural::One(x.into_inner()), + Plural::Many(xs) => Plural::Many(xs.into_iter().map(|x| x.into_inner()).collect()), + }; + } +} + +impl Plural { + pub fn to_array(self) -> Vec { return match self { Plural::Zero => Vec::new(), Plural::One(val) => vec![val], Plural::Many(vals) => vals, }; } + + pub fn map(self, f: F) -> Plural + where + F: Fn(&T) -> R, + { + return match self { + Plural::Zero => Plural::Zero, + Plural::One(x) => Plural::One(f(&x)), + Plural::Many(xs) => Plural::Many(xs.iter().map(f).collect()), + }; + } } impl Plural { @@ -100,24 +216,33 @@ impl Plural { impl Merging for Option { fn merge(self, new: Self) -> Self { - info!("Merging `Option`"); return match new { - Some(x) => match self { - Some(y) => Some(y.merge(x)), - None => Some(x), + Some(newval) => match self { + Some(oldval) => Some(oldval.merge(newval)), + None => Some(newval), }, None => self, }; } + + fn coalesce(self, new: Self) -> Self { + return new.or(self); + } } impl Merging for String { - fn merge(self, _: Self) -> Self { - return self; + fn merge(self, new: Self) -> Self { + return new; + } + fn coalesce(self, new: Self) -> Self { + return new; } } impl Merging for toml::Value { + fn coalesce(self, new: Self) -> Self { + return new; + } fn merge(self, new: Self) -> Self { match new { Value::Array(new_values) => match self { From c0dad48bc854aacaa3aa5649a385e524bb576b76 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 25 Jul 2025 21:34:16 -0400 Subject: [PATCH 13/79] notes Created using spr 1.3.6-beta.1 --- notes.md | 20 ++++---------------- src/rust/parsing/src/bind.rs | 2 -- 2 files changed, 4 insertions(+), 18 deletions(-) diff --git a/notes.md b/notes.md index 14d25c67..9f354f93 100644 --- a/notes.md +++ b/notes.md @@ -79,24 +79,12 @@ Integration test debugging: - [X] rustup toolchain install nightly - [X] foreach expansion (unit tests remain) - [X] expand keys in `foreach` lists - - [ ] include `Spanned` in fields of `BindInput` - - [ ] remove `computedArgs` and related functionality - and replace with more generic "{{value}}" replacement - (permitting the injection of e.g. objects, not just strings) - this can replace `[[default]]` and `default` elements as well - NOTE: internally we still use `computedArgs` in the binding - object `Binding`---it's only removed for `BindingInput`--- - this ensures a fast path for commands that don't have a computed argument - and limits the time to search and replace commands during binding - execution - TODO: we'll need to check for any remaining `{{}}` arguments - once `foreach` gets expanded and `computedArgs` gets completed - - [ ] format error messages appropriately - - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region - - [ ] validate by checking error reporting - NOTE: short term goal here is to support literate docs + - [x] include `Spanned` in fields of `BindInput` + - [ ] cleanup and refactor code - [ ] pipeline for `[[bind]]` entries - [ ] basic pipeline + - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region + NOTE: short term goal here is to support literate docs - [ ] proper parsing with `[[default]]` and `defaults` - [ ] foreach expansion - [ ] command normalization (always `runCommand` with an array of objects with `command` field) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 7902326f..50083fff 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -8,8 +8,6 @@ use crate::bind::validation::{JsonObjectShape, valid_json_array_object, valid_ke use crate::error::{Context, ErrorContext, Result, constrain, unexpected}; use crate::util::{Merging, Plural, Required, Requiring, Resolving}; -use js_sys::Intl::PluralRules; -use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use serde::{Deserialize, Serialize}; From a0a1c1f2d7c9d209e8d51810fe58ff654a605401 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 29 Jul 2025 00:51:09 -0400 Subject: [PATCH 14/79] preliminary file processing pipeline skeleton Created using spr 1.3.6-beta.1 --- mise.toml | 37 ++++++++------- notes.md | 4 +- src/rust/parsing/src/bind.rs | 57 ++++++++-------------- src/rust/parsing/src/error.rs | 10 ++-- src/rust/parsing/src/file.rs | 89 +++++++++++++++++++++++++++++++++++ src/rust/parsing/src/lib.rs | 1 + 6 files changed, 137 insertions(+), 61 deletions(-) create mode 100644 src/rust/parsing/src/file.rs diff --git a/mise.toml b/mise.toml index 0b37d62f..b369ce65 100644 --- a/mise.toml +++ b/mise.toml @@ -44,24 +44,27 @@ coverage_options = '''--ignore-filename-regex '/.cargo/registry' --ignore-filena dir = 'src/rust/parsing' shell = 'nu -c' run = ''' -if ($env.COVERAGE? | default false | into bool) { - $env.RUSTFLAGS = '-C instrument-coverage' - $env.LLVM_PROFILE_FILE = 'coverage/parsing.profraw' - - let object_files = cargo +nightly test --tests --no-run --message-format=json | - from json -o | where profile?.test | - get filenames.0 | - each { |f| $'--object=($in)' } - - cargo +nightly test --tests - cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata - (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> - ../../../coverage/rs_coverage.info) - - cargo cov -- report --use-color {{vars.coverage_options}} ...($object_files) -} else { - cargo test +def main [...args] { + if ($env.COVERAGE? | default false | into bool) { + $env.RUSTFLAGS = '-C instrument-coverage' + $env.LLVM_PROFILE_FILE = 'coverage/parsing.profraw' + + let object_files = cargo +nightly test --tests --no-run --message-format=json | + from json -o | where profile?.test | + get filenames.0 | + each { |f| $'--object=($in)' } + + cargo +nightly test --tests ...$args + cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata + (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> + ../../../coverage/rs_coverage.info) + + cargo cov -- report --use-color {{vars.coverage_options}} ...($object_files) + } else { + cargo test ...$args + } } +main ''' [tasks.build] diff --git a/notes.md b/notes.md index 9f354f93..d88ff819 100644 --- a/notes.md +++ b/notes.md @@ -80,11 +80,13 @@ Integration test debugging: - [X] foreach expansion (unit tests remain) - [X] expand keys in `foreach` lists - [x] include `Spanned` in fields of `BindInput` - - [ ] cleanup and refactor code - [ ] pipeline for `[[bind]]` entries - [ ] basic pipeline - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs + - [ ] cleanup and refactor code + - NOTE: we're waiting until we test out spans, because that could require + more refactoring - [ ] proper parsing with `[[default]]` and `defaults` - [ ] foreach expansion - [ ] command normalization (always `runCommand` with an array of objects with `command` field) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 50083fff..4ebdced6 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -1,3 +1,5 @@ +// parsing of individual `[[bind]]` elements + #![allow(non_snake_case)] mod foreach; @@ -81,17 +83,6 @@ pub struct BindingInput { #[serde(default)] args: Option>, - /** - * @forBindingField bind - * - * - `computedArgs`: Like `args` except that each value is a string that is - * evaluated as an [expression](/expressions/index). - */ - // TODO: Spanned>, - /** * @forBindingField bind * @@ -176,13 +167,15 @@ pub struct BindingInput { /** * @forBindingField bind * - * - `computedRepeat`: This is an [expression](/expressions/index). It is expected + * **TODO**: update docs, and make it possible to be a number or a string + * + * - `repeat`: This is an [expression](/expressions/index). It is expected * to evaluate to the number of times to repeat the command. Defaults to zero: one * repeat means the command is run twice. * - `command` will be repeated the given * number of times. */ - computedRepeat: Option>, + repeat: Option>, /** * @forBindingField bind @@ -260,7 +253,6 @@ impl Merging for BindingInput { BindingInput { command: self.command.coalesce(y.command), args: self.args.merge(y.args), - computedArgs: self.computedArgs.merge(y.computedArgs), key: self.key.coalesce(y.key), when: self.when.coalesce(y.when), mode: self.mode.coalesce(y.mode), @@ -269,7 +261,7 @@ impl Merging for BindingInput { foreach: self.foreach, prefixes: self.prefixes.coalesce(y.prefixes), finalKey: self.finalKey.coalesce(y.finalKey), - computedRepeat: self.computedRepeat.coalesce(y.computedRepeat), + repeat: self.repeat.coalesce(y.repeat), name: self.name.coalesce(y.name), description: self.description.coalesce(y.description), hideInPalette: self.hideInPalette.coalesce(y.hideInPalette), @@ -289,6 +281,7 @@ pub struct Command { pub args: JsValue, } +#[derive(Clone)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct Binding { @@ -300,7 +293,7 @@ pub struct Binding { pub defaults: String, pub prefixes: Vec, pub finalKey: bool, - pub computedRepeat: Option, + pub repeat: Option, pub name: Option, pub description: Option, pub hideInPalette: Option, @@ -365,7 +358,6 @@ impl BindingInput { return BindingInput { command: self.command.expand_foreach_value(var, value), args: self.args.expand_foreach_value(var, value), - computedArgs: self.computedArgs.expand_foreach_value(var, value), key: self.key.expand_foreach_value(var, value), when: self.when.expand_foreach_value(var, value), mode: self.mode.expand_foreach_value(var, value), @@ -373,7 +365,7 @@ impl BindingInput { defaults: self.defaults.expand_foreach_value(var, value), prefixes: self.prefixes.expand_foreach_value(var, value), finalKey: self.finalKey.clone(), - computedRepeat: self.computedRepeat.expand_foreach_value(var, value), + repeat: self.repeat.expand_foreach_value(var, value), foreach: None, name: self.name.expand_foreach_value(var, value), description: self.description.expand_foreach_value(var, value), @@ -391,6 +383,7 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Result<(BindingInput, Vec Result<(BindingInput, Vec 1".into())); assert_eq!(result.mode.into_inner(), Plural::One("normal".into())); @@ -591,7 +583,6 @@ mod tests { [[bind]] name = "default" command = "cursorMove" - computedArgs.value = "count" prefixes = ["a"] [[bind]] @@ -617,16 +608,6 @@ mod tests { .unwrap(), "left" ); - assert_eq!( - left.computedArgs - .unwrap() - .into_inner() - .get("value") - .unwrap() - .as_str() - .unwrap(), - "count" - ); assert_eq!( left.prefixes.into_inner(), Plural::Many(vec!["b".into(), "c".into()]) diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 7cdc6ec6..c0d79c10 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,12 +1,13 @@ use std::fmt; use thiserror::Error; +use wasm_bindgen::prelude::*; use crate::bind::UNKNOWN_RANGE; use core::ops::Range; // TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) -#[derive(Debug, Error)] +#[derive(Debug, Error, Clone)] pub enum Error { #[error("parsing {0}")] Parsing(#[from] toml::de::Error), @@ -14,8 +15,6 @@ pub enum Error { Validation(#[from] validator::ValidationError), #[error("expected {0}")] ConstraintError(&'static str), - #[error("unexpected error binding rust values to javascript - {0}")] - JavaScriptError(#[from] serde_wasm_bindgen::Error), #[error("required {0}")] RequiredField(&'static str), #[error("unexpected {0}")] @@ -24,14 +23,15 @@ pub enum Error { Regex(#[from] regex::Error), } -#[derive(Debug, Error)] +#[wasm_bindgen] +#[derive(Debug, Error, Clone)] pub struct ErrorWithContext { #[source] error: Error, contexts: Vec, } -#[derive(Debug)] +#[derive(Debug, Clone)] pub enum Context { String(String), Range(Range), diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs new file mode 100644 index 00000000..7f7276c2 --- /dev/null +++ b/src/rust/parsing/src/file.rs @@ -0,0 +1,89 @@ +// top-level parsing of an entire file +use crate::bind::{Binding, BindingInput}; +use crate::error::{Error, ErrorWithContext, Result}; + +use serde::{Deserialize, Serialize}; +use wasm_bindgen::prelude::*; + +// TODO: copy over docs from typescript +#[derive(Deserialize, Clone, Debug)] +struct KeyFileInput { + bind: Vec, +} + +#[derive(Clone)] +#[allow(non_snake_case)] +#[wasm_bindgen(getter_with_clone)] +struct KeyFile { + bind: Vec, +} + +impl KeyFile { + fn new(input: KeyFileInput) -> Result { + return Ok(KeyFile { + bind: input + .bind + .into_iter() + .map(|b| Binding::new(b)) + .collect::>>()?, + }); + } +} + +#[wasm_bindgen(getter_with_clone)] +pub struct KeyFileResult { + pub file: Option, + pub error: Option, +} + +#[wasm_bindgen] +pub fn parse_string(file_content: &str) -> KeyFileResult { + return match parse_string_helper(file_content) { + Ok(result) => KeyFileResult { + file: Some(result), + error: None, + }, + Err(err) => KeyFileResult { + file: None, + error: Some(err), + }, + }; +} + +fn parse_string_helper(file_content: &str) -> Result { + let result = toml::from_str::(file_content)?; + return KeyFile::new(result); +} + +#[cfg(test)] +mod tests { + use super::*; + use test_log::test; + + #[test] + fn parse_example() { + let data = r#" + [[bind]] + key = "l" + mode = "normal" + command = "cursorRight" + + [[bind]] + key = "h" + model = "normal" + command = "cursorLeft" + "#; + + let result = parse_string(data); + assert_eq!(result.file.as_ref().unwrap().bind[0].key, "l"); + assert_eq!( + result.file.as_ref().unwrap().bind[0].commands[0].command, + "cursorRight" + ); + assert_eq!(result.file.as_ref().unwrap().bind[1].key, "h"); + assert_eq!( + result.file.as_ref().unwrap().bind[1].commands[0].command, + "cursorLeft" + ); + } +} diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index cf4d2d1a..3731781a 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,5 +1,6 @@ pub mod bind; mod error; +mod file; mod util; use wasm_bindgen::prelude::*; From 1fd3d743e7e200cba38ee829457be9d48dd57298 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 29 Jul 2025 10:59:26 -0400 Subject: [PATCH 15/79] pipeline can be run from typescript command Created using spr 1.3.6-beta.1 --- mise.toml | 7 +-- notes.md | 2 +- src/extension/keybindings/index.ts | 70 +++++++++++++++++------------- src/rust/parsing/src/error.rs | 49 +++++++++++++++++++++ src/rust/parsing/src/file.rs | 15 ++++--- src/rust/parsing/src/lib.rs | 15 +++---- 6 files changed, 109 insertions(+), 49 deletions(-) diff --git a/mise.toml b/mise.toml index b369ce65..2e10c5bd 100644 --- a/mise.toml +++ b/mise.toml @@ -33,6 +33,7 @@ outputs = ['out/**/*.wasm', 'src/rust/parsing/lib/*'] dir = 'src/rust/parsing' run = [ 'wasm-pack build --target web --out-dir lib', + 'mkdir -p ../../../out', 'cp lib/parsing_bg.wasm ../../../out/parsing_bg.wasm', ] @@ -54,14 +55,14 @@ def main [...args] { get filenames.0 | each { |f| $'--object=($in)' } - cargo +nightly test --tests ...$args + cargo +nightly test --tests ...$args -- --nocapture cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> ../../../coverage/rs_coverage.info) cargo cov -- report --use-color {{vars.coverage_options}} ...($object_files) } else { - cargo test ...$args + cargo test ...$args -- --nocapture } } main @@ -70,7 +71,7 @@ main [tasks.build] depends = ['check-types', 'lint', 'build-rust'] sources = ['src/**/*.ts'] -run = ['pwd', 'node esbuild.mjs'] +run = 'node esbuild.mjs' [tasks.package] depends = ['check-types', 'lint', 'build-rust'] diff --git a/notes.md b/notes.md index d88ff819..4f88dba7 100644 --- a/notes.md +++ b/notes.md @@ -81,7 +81,7 @@ Integration test debugging: - [X] expand keys in `foreach` lists - [x] include `Spanned` in fields of `BindInput` - [ ] pipeline for `[[bind]]` entries - - [ ] basic pipeline + - [X] basic pipeline - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] cleanup and refactor code diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index f571107f..35bb69a6 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -25,8 +25,8 @@ import { toLayoutIndependentString } from './layout'; import JSONC from 'jsonc-simple-parser'; import TOML from 'smol-toml'; -// run `mise build-rust` to create this auto generated source file -import initParsing, { simple, debug_parse_command } from '../../rust/parsing/lib'; +// run `mise build-rust` to create this auto generated source fileu +import initParsing, { parse_string } from '../../rust/parsing/lib'; //////////////////////////////////////////////////////////////////////////////////////////// // Keybinding Generation @@ -653,19 +653,18 @@ export async function activate(context: vscode.ExtensionContext) { context.subscriptions.push( vscode.commands.registerCommand('master-key.test-rust', () => { - const parsing = debug_parse_command(` + const parsed = parse_string(` + [[bind]] command = "do" args = { a = "2", b = 3 } - computedArgs = { c = "1+2" } key = "a" when = "joe > 1" mode = "normal" priority = 1 defaults = "foo.bar" - foreach.index = [1,2,3] prefixes = "c" finalKey = true - computedRepeat = "2+c" + repeat = "2+c" name = "foo" description = "foo bar bin" hideInPalette = false @@ -677,31 +676,40 @@ export async function activate(context: vscode.ExtensionContext) { whenComputed = "f > 2" `); - vscode.window.showInformationMessage(`Rust says: - command: ${parsing.command} - args: ${JSON.stringify(parsing.args, null, 2)} - computedArgs: ${JSON.stringify(parsing.computedArgs, null, 2)} - key: ${parsing.key} - when: ${parsing.when} - mode: ${parsing.mode} - priority: ${parsing.priority} - defaults: ${parsing.defaults} - prefixes: ${parsing.prefixes} - finalKey: ${parsing.finalKey} - computedRepeat: ${parsing.computedRepeat} - name: ${parsing.name} - description: ${parsing.description} - hideInPalette: ${parsing.hideInPalette} - hideInDocs: ${parsing.hideInDocs} - combinedName: ${parsing.combinedName} - combinedKey: ${parsing.combinedKey} - combinedDescription: ${parsing.combinedDescription} - kind: ${parsing.kind} - whenComputed: ${parsing.whenComputed} - `); - const result = simple(); - vscode.window.showInformationMessage('Rust says: "' + result + '"'); - return result; + if (parsed.file) { + const binding = parsed.file.bind[0]; + vscode.window.showInformationMessage(`Rust says: + command: ${binding.commands[0].command}, + args: ${JSON.stringify(binding.commands[0].args, null, 2)} + key: ${binding.key} + when: ${binding.when} + mode: ${binding.mode} + priority: ${binding.priority} + defaults: ${binding.defaults} + prefixes: ${binding.prefixes} + finalKey: ${binding.finalKey} + computedRepeat: ${binding.repeat} + name: ${binding.name} + description: ${binding.description} + hideInPalette: ${binding.hideInPalette} + hideInDocs: ${binding.hideInDocs} + combinedName: ${binding.combinedName} + combinedKey: ${binding.combinedKey} + combinedDescription: ${binding.combinedDescription} + kind: ${binding.kind} + `); + } else if (parsed.error) { + const report = parsed.error.report(); + let message = ''; + for (const item of report.items) { + message += (item.message || '') + ' at ' + + (item.range ? `(${item.range.start}, ${item.range.end})` : '') + + '\n'; + } + vscode.window.showErrorMessage( + 'Parsing error: ' + message, + ); + } }), ); diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index c0d79c10..07832e29 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -23,6 +23,8 @@ pub enum Error { Regex(#[from] regex::Error), } +// TODO: figure out how to expose errors in wasm +// (maybe we output some regular formatting structure rather than individual error types) #[wasm_bindgen] #[derive(Debug, Error, Clone)] pub struct ErrorWithContext { @@ -31,6 +33,53 @@ pub struct ErrorWithContext { contexts: Vec, } +#[wasm_bindgen] +impl ErrorWithContext { + pub fn report(&self) -> ErrorReport { + let mut items = Vec::with_capacity(self.contexts.len() + 1); + items.push(ErrorReportItem { + message: Some(self.error.to_string()), + range: None, + }); + for context in &self.contexts { + let item = match context { + Context::String(str) => ErrorReportItem { + message: Some(str.clone()), + range: None, + }, + Context::Range(range) => ErrorReportItem { + message: None, + range: Some(ByteRange { + start: range.start, + end: range.end, + }), + }, + }; + items.push(item); + } + return ErrorReport { items }; + } +} + +#[wasm_bindgen(getter_with_clone)] +pub struct ErrorReport { + pub items: Vec, +} + +#[wasm_bindgen] +#[derive(Debug, Clone)] +pub struct ByteRange { + pub start: usize, + pub end: usize, +} + +#[wasm_bindgen(getter_with_clone)] +#[derive(Debug, Clone)] +pub struct ErrorReportItem { + pub message: Option, + pub range: Option, +} + #[derive(Debug, Clone)] pub enum Context { String(String), diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 7f7276c2..111c9d57 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,21 +1,23 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; -use crate::error::{Error, ErrorWithContext, Result}; +use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result}; +use log::info; use serde::{Deserialize, Serialize}; +use toml::Spanned; use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript #[derive(Deserialize, Clone, Debug)] struct KeyFileInput { - bind: Vec, + bind: Vec>, } #[derive(Clone)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] -struct KeyFile { - bind: Vec, +pub struct KeyFile { + pub bind: Vec, } impl KeyFile { @@ -24,7 +26,10 @@ impl KeyFile { bind: input .bind .into_iter() - .map(|b| Binding::new(b)) + .map(|b| { + let span = b.span(); + return Binding::new(b.into_inner()).context(Context::Range(span)); + }) .collect::>>()?, }); } diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 3731781a..eb895cda 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,11 +1,8 @@ -pub mod bind; -mod error; -mod file; +// error reporting +pub mod error; mod util; -use wasm_bindgen::prelude::*; - -#[wasm_bindgen] -pub fn simple() -> String { - return "hello from rust!".into(); -} +// [[bind]] level parsing +mod bind; +// file level parsing +pub mod file; From 8dbc2f9ef6040c09d1fe612bd3bb56231e4b3984 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 30 Jul 2025 21:35:01 -0400 Subject: [PATCH 16/79] tweaks Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/bind.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 4ebdced6..e536d261 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -383,7 +383,6 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Date: Wed, 30 Jul 2025 21:35:38 -0400 Subject: [PATCH 17/79] updated larkin bindings to aspirational format Created using spr 1.3.6-beta.1 --- src/presets/larkin.toml | 998 +++++++++++++++++++--------------------- 1 file changed, 467 insertions(+), 531 deletions(-) diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index beefbe1a..d2b7181c 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -82,10 +82,9 @@ Assorted other commands that aren't motions or actions command = "selection-utilities.shrinkToActive" [[define.selectLinesDown]] -whenComputed = "count" +abort = "{{count <= 0}}" command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true } -computedArgs = { value = "count" } +args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" } [[define.selectLinesDown]] command = "expandLineSelection" @@ -94,18 +93,15 @@ command = "expandLineSelection" command = "selection-utilities.shrinkToActive" [[define.selectLinesUp]] -whenComputed = "count" +abort = "{{count <= 0}}" command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true } -computedArgs = { value = "count" } +args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" } [[define.selectLinesUp]] command = "expandLineSelection" - -[[default]] -id = "modes" -default.kind = "util" +[define.modes] +kind = "util" # ## Getting Help @@ -116,7 +112,7 @@ default.kind = "util" # 3. The suggestion palette shows a list of the current bindings given the current key binding prefix. [[bind]] -defaults = "util" +merge = "{{util}}" key = "shift+;" name = "suggest" finalKey = false @@ -158,7 +154,7 @@ command = "master-key.showVisualDoc" # While in Normal model you will see a highlighted section with the text "normal" in the lower left hand corner of the status bar. [[bind]] -defaults = "modes" +merge = "{{modes}}" name = "normal" description = "Enter normal mode" foreach.key = ["escape", "ctrl+["] @@ -174,7 +170,7 @@ when = "!findWidgetVisible" prefixes = "{{all_prefixes}}" [[bind]] -defaults = "modes" +merge = "{{modes}}" name = "normal" foreach.key = ["escape", "ctrl+["] key = "{{key}}" @@ -188,7 +184,7 @@ prefixes = "{{all_prefixes}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect [[bind]] -defaults = "modes" +merge = "{{modes}}" name = "ignore" description = "this key does nothing" foreach.key = [ @@ -204,14 +200,13 @@ hideInDocs = true hideInPalette = true priority = -10 -[[default]] -id = "edit" -appendWhen = "editorTextFocus && !findWidgetVisible" -default.mode = "normal" +[define.edit] +when = "editorTextFocus && !findWidgetVisible" +mode = "normal" -[[default]] -id = "edit.count" -default.kind = "count" +[define.edit_count] +merge = "{{edit}}" +kind = "count" # ## Basic motions @@ -219,18 +214,19 @@ default.kind = "count" # Selection behavior uses the following logic: motions that move more than one character generally select the text "under" the motion. If a selection already exists (e.g. from a previous motion) additional motions extend that selection. You can always reset the selection using `v`, and several commands (e.g. `x`) operate on the next character rather than the current selection. -[[default]] -id = "edit.motion" -default.kind = "motion" +[define.edit_motion] +merge = "{{edit}}" +kind = "motion" +tags = ["motion"] -[[default]] -id = "edit.motion.prim" -default.command = "cursorMove" -default.computedArgs.value = "count" -default.computedArgs.select = "editorHasSelection || select_on" +[define.edit_motion_prim] +merge = "{{edit_motion}}" +command = "cursorMove" +value = "{{count}}" +select = "{{editorHasSelection || select_on}}" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "h" name = "←" combinedName = "←/→" @@ -241,7 +237,7 @@ args.to = "left" mode = "normal" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "l" combinedName = "←/→" name = "→" @@ -249,7 +245,7 @@ description = "move right" args.to = "right" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "j" name = "↓" combinedName = "↓/↑" @@ -260,7 +256,7 @@ args.to = "down" args.by = "wrappedLine" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "k" name = "↑" description = "move up" @@ -269,7 +265,7 @@ args.to = "up" args.by = "wrappedLine" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "shift+h" name = "start" description = "start of line (alternates between first non-white and first)" @@ -279,7 +275,7 @@ combinedDescription = "move to start/end of line" command = "cursorHomeSelect" [[bind]] # we don't use prim because we don't want the defaults -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "shift+l" name = "end" combinedName = "start/end" @@ -289,7 +285,7 @@ args.to = "wrappedLineEnd" args.select = true [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "shift+k" name = "sel ↑" combinedName = "sel ↑/↓" @@ -303,8 +299,7 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true } -computedArgs = { value = "count" } +args = { to = "up", by = "wrappedLine", select = true, value = "count" } [[bind.args.commands]] command = "expandLineSelection" @@ -313,7 +308,7 @@ command = "expandLineSelection" command = "selection-utilities.exchangeAnchorActive" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "shift+j" name = "sel ↓" combinedName = "sel ↑/↓" @@ -325,14 +320,13 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true } -computedArgs = { value = "count" } +args = { to = "down", by = "wrappedLine", select = true, value = "count" } [[bind.args.commands]] command = "expandLineSelection" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "ctrl+d" mode = ["normal", "insert"] name = "pg ↓" @@ -342,11 +336,11 @@ combinedDescription = "move down/up, relative to page size" description = "move down, relative to page size" command = "selection-utilities.activePageMove" args.dir = "down" -computedArgs.count = "(count || 1)/3" -computedArgs.select = "mode == 'normal'" +args.count = "{{(count || 1)/3}}" +args.select = "{{mode == 'normal'}}" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "ctrl+u" mode = ["normal", "insert"] name = "pg ↑" @@ -354,25 +348,24 @@ combinedName = "pg ↓/↑" description = "move up, relative to page size" command = "selection-utilities.activePageMove" args.dir = "up" -computedArgs.count = "(count || 1)/3" -computedArgs.select = "mode == 'normal'" +args.count = "{{(count || 1)/3}}" +args.select = "{{mode == 'normal'}}" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "shift+x" name = "exapand" description = "expand selections to full lines" command = "expandLineSelection" -computedRepeat = "count" +computedRepeat = "{{count}}" -[[default]] -id = "edit.motion.obj" -default.command = "selection-utilities.moveBy" -default.args.boundary = "start" -default.args.select = true +[[define.edit_motion_obj]] +command = "selection-utilities.moveBy" +args.boundary = "start" +args.select = true [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "w" name = "subwrd →" description = "next subword (camel/snake case)" @@ -380,19 +373,19 @@ combinedName = "subwrd ←/→" combinedDescription = "next/prev subword (camel/snake case)" combinedKey = "w/b" args.unit = "subword" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "b" name = "subwrd ←" description = "previous subword (camel/snake case)" combinedName = "subwrd ←/→" args.unit = "subword" -computedArgs.value = "-count || -1" +args.value = "{{-count || -1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+w" name = "word →" description = "next word" @@ -400,37 +393,37 @@ combinedName = "word ←/→" combinedDescription = "next/prev word" combinedKey = "shift+w/b" args.unit = "word" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+b" name = "word ←" combinedName = "word ←/→" description = "previous word" args.unit = "word" -computedArgs.value = "-count || -1" +args.value = "{{-count || -1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "e" name = "subwrd end" description = "next subword (camel/snake case) end" args.unit = "subword" args.boundary = "end" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+e" name = "word end" description = "next word end" args.unit = "word" args.boundary = "end" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+]" name = "parag. →" description = "next paragraph" @@ -438,19 +431,19 @@ combinedName = "paragraph →/←" combinedDescription = "next/previous paragraph" combinedKey = "shift+]/[" args.unit = "paragraph" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+[" name = "parag. ←" combinedName = "paragraph →/←" description = "previous paragraph" args.unit = "paragraph" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+0" name = "subsec →" description = "next subsection" @@ -458,19 +451,19 @@ combinedName = "subsec →/←" combinedDescription = "next/previous subsection" combinedKey = "shift+0/9" args.unit = "subsection" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+9" name = "subsec ←" description = "previous subsection" combinedName = "subsec →/←" args.unit = "subsection" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "v" name = "shrink selection" combinedName = "shrink/hold selection" @@ -487,7 +480,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.motion.mod" +merge = "{{edit_motion}}" key = "shift+v" name = "hold selection" combinedName = "shrink/hold selection" @@ -499,7 +492,7 @@ args.name = "select_on" args.value = true [[bind]] -defaults = "edit.action.open_lines" +merge = "{{edit_action}}" name = "open, act →" description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" key = "o" @@ -509,19 +502,19 @@ combinedDescription = """ without selection: open a line below/above current line and enter insert, with selection: move cursor to end/start of selection """ -when = "!editorHasSelection" +when = "!editorHasSelection && {{merged.when}}" command = "runCommands" args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] [[bind]] -defaults = "edit.action.open_lines" +merge = "{{edit_action}}" key = "o" combinedName = "open below/above, act →/←" when = "editorHasSelection" command = "selection-utilities.activeAtEnd" [[bind]] -defaults = "edit.action.open_lines" +merge = "{{edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -531,7 +524,7 @@ command = "runCommands" args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -defaults = "edit.action.open_lines" +merge = "{{edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -540,14 +533,14 @@ when = "editorHasSelection" command = "selection-utilities.activeAtStart" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "shift+5" name = "to bracket" description = "Move to matching bracket" command = "editor.action.jumpToBracket" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = '\' name = "→ sel" combinedName = "→/← sel" @@ -562,11 +555,10 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "right", select = true } -computedArgs = { value = "count" } +args = { to = "right", select = true, value = "{{count}}" } [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = 'shift+\' name = "← sel" combinedName = "→/← sel" @@ -579,29 +571,24 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "left", select = true } -computedArgs = { value = "count" } - -[[default]] -id = "edit.motion.mod" -default.kind = "motion" +args = { to = "left", select = true, value = "{{count}}" } [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "shift+4" name = "all" description = "Select entire document" command = "editor.action.selectAll" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "shift+r" name = "trim wht" description = "trim external whitespace" command = "selection-utilities.trimSelectionWhitespace" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" name = "→ num." description = "Move to next number" key = "shift+3" @@ -611,10 +598,10 @@ combinedKey = "shift+3/2" args.unit = "number" args.selectWhole = true args.boundary = "both" -computedArgs.value = "(count || 1)" +args.value = "{{(count || 1)}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" name = "← num." description = "Move to next number" key = "shift+2" @@ -622,10 +609,10 @@ combinedName = "→/← num." args.unit = "number" args.selectWhole = true args.boundary = "both" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = 'narrow to subword' description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" key = "z" @@ -640,7 +627,6 @@ args.boundary = "both" # times e.g. 2w would select the next two words starting from the current cursor position. [[bind]] -defaults = "edit.count" foreach.num = ['{{key: [0-9]}}'] name = "count {{num}}" key = "{{num}}" @@ -656,26 +642,23 @@ hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions -[[default]] -id = "edit.motion.history" - [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" key = ";" name = "repeat motion" description = """ Repeat the last motion command. Motions usually move the cursor or change the selection. """ -computedRepeat = "count" +computedRepeat = "{{count}}" command = "master-key.replayFromHistory" args.whereComputedIndexIs = """ -commandHistory[index].defaults.startsWith('edit.motion') && +commandHistory[index].tags.contains('motion') && commandHistory[index].name != 'repeat motion' && commandHistory[index].name != 'shrink selection' """ [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "repeat subject" description = """ Repeat the subject: a motion command that occurred right before an action. For @@ -685,14 +668,14 @@ last subject until some new action is run after `d`. See also `.` which repeats key = "," command = "master-key.replayFromHistory" args.whereComputedIndexIs = """ -commandHistory[index].path.startsWith("edit.motion") && -commandHistory[index+1].path.startsWith("edit.action") && -!(commandHistory[index+1].name.startsWith("repeat ") && - commandHistory[index+1].path.startsWith("edit.action.history")) +commandHistory[index].tags.contains("motion") && +commandHistory[index+1].tags.contains("action") && +!(commandHistory[index+1].name.startsWith("repeat") && +commandHistory[index+1].tags.contains("history")) """ [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "cursor undo" key = "-" combinedName = "cursor undo/redo" @@ -700,14 +683,14 @@ combinedKey = "-/shift+-" command = "cursorUndo" [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "cursor redo" combinedName = "cursor undo/redo" key = "shift+-" command = "cursorRedo" [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "nav ←" description = "Go back in navigation history (e.g. goto definition)" combinedName = "nav ←/→" @@ -717,7 +700,7 @@ key = "g n" command = "workbench.action.navigateBackInNavigationLocations" [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "nav →" combinedName = "nav ←/→" description = "Go forward in navigation history (e.g. goto definition)" @@ -725,7 +708,7 @@ key = "g shift+n" command = "workbench.action.navigateForwardInNavigationLocations" [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "edit hist ←" description = "Go back in edit history" key = "g -" @@ -735,7 +718,7 @@ combinedDescription = "Go back/forward in edit history" command = "workbench.action.navigateBackInEditLocations" [[bind]] -defaults = "edit.motion.history" +merge = "{{edit_motion}}" name = "edit hist →" description = "Go forward in edit history)" key = "g shift+-" @@ -748,16 +731,16 @@ command = "workbench.action.navigateForwardInEditLocations" # # > I want some food -[[default]] -id = "edit.motion.search" -default.command = "master-key.search" -default.args.caseSensitive = false -default.args.backwards = false -default.args.selectTillMatch = true -default.args.wrapAround = true +[define.edit_motion_search] +merge = "{{edit_motion}}" +command = "master-key.search" +args.caseSensitive = false +args.backwards = false +args.selectTillMatch = true +args.wrapAround = true [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "/" name = "search →" description = "search forwards" @@ -768,7 +751,7 @@ args.offset = "start" args.register = "search" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+/" name = "search ←" description = "search backwards" @@ -778,48 +761,48 @@ args.register = "search" args.backwards = true [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "n" name = "→ search" description = "Go to the next match of the search query" command = "master-key.nextMatch" args.register = "search" -computedArgs.computedRepeat = "(count || 1)-1" +args.repeat = "{{(count || 1)-1}}" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+n" name = "← search" description = "Go to the previous match of the search query" command = "master-key.previousMatch" args.register = "search" -computedArgs.computedRepeat = "(count || 1)-1" +args.repeat = "{{(count || 1)-1}}" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+8" name = "match →" description = "Next match to object under cursor" combinedName = "match →/←" combinedDescription = "Next/previous match to object under cursor" combinedKey = "shift+8/7" -computedArgs.text = "firstSelectionOrWord" +args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+7" name = "match ←" description = "Previous match to object under cursor" combinedName = "match →/←" -computedArgs.text = "firstSelectionOrWord" +args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" args.backwards = true [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "f" name = "find char" description = "Find the next char (include char in selection)" @@ -827,11 +810,11 @@ combinedName = "find char (back)" combinedDescription = "Find the next (previous) char (include char in selection)" combinedKey = "f (shift+f)" args.acceptAfter = 1 -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" args.offset = "inclusive" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+f" name = "find char back" description = "Find the previous char (include char in selection)" @@ -839,10 +822,10 @@ combinedName = "find char (back)" args.acceptAfter = 1 args.offset = "inclusive" args.backwards = true -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "t" name = "to char" description = "Find the next char (exclude char in selection)" @@ -851,10 +834,10 @@ combinedKey = "t (shift+t)" combinedDescription = "Find the next/previous char (exclude char in selection)" args.acceptAfter = 1 args.offset = "start" -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+t" name = "to char back" description = "Find the previous char (exclude char in selection)" @@ -862,10 +845,10 @@ combinedName = "to char (back)" args.acceptAfter = 1 args.offset = "end" args.backwards = true -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "s" name = "find char pair" description = "To next character pair" @@ -874,18 +857,18 @@ combinedDescription = "To next character pair" combinedKey = "s/shift+s" args.acceptAfter = 2 args.offset = "start" -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" mode = "normal" [[bind]] -defaults = "edit.motion.search" +merge = "{{edit_motion_search}}" key = "shift+s" name = "char pair back" description = "To previous character pair" combinedName = "char pair →/←" args.acceptAfter = 2 args.offset = "start" -computedArgs.skip = "count-1" +args.skip = "{{count-1}}" args.backwards = true # ## Goto Commands @@ -894,7 +877,7 @@ args.backwards = true # motion commands that compliment the basic motions listed in the previous section. [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "g" priority = 1 name = "goto" @@ -905,7 +888,7 @@ or backwards in some direction. """ [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g j" priority = 1 name = "unwrp ↓" @@ -923,7 +906,7 @@ args.to = "down" args.by = "line" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g k" priority = 1 name = "unwrp ↑" @@ -933,7 +916,7 @@ args.to = "up" args.by = "line" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g shift+k" priority = 1 combinedName = "unwrp sel ↑/↓" @@ -948,14 +931,14 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "up", by = "line", select = true } -computedArgs = { value = "count" } +args = { to = "up", by = "line", select = true, value = "{{count}}" } + [[bind.args.commands]] command = "expandLineSelection" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g shift+j" priority = 1 name = "sel ↓" @@ -968,14 +951,14 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "down", by = "line", select = true } -computedArgs = { value = "count" } +args = { to = "down", by = "line", select = true, value = "{{count}}" } + [[bind.args.commands]] command = "expandLineSelection" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "shift+g" priority = 1 name = "doc end" @@ -986,7 +969,7 @@ combinedKey = ",/." command = "cursorBottomSelect" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -1001,15 +984,15 @@ command = "cursorTop" command = "cursorMove" args.to = "down" args.by = "wrappedLine" -computedArgs.value = "count-1" +args.value = "{{count-1}}" [[bind.args.commands]] command = "revealLine" args.at = "center" -computedArgs.lineNumber = "count" +args.lineNumber = "{{count}}" [[bind]] -defaults = "edit.motion.prim" +merge = "{{edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -1018,7 +1001,7 @@ command = "cursorTopSelect" when = "master-key.count <= 1" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "g w" priority = 1 name = "WORD →" @@ -1029,30 +1012,30 @@ next/prev WORD; e.g. contiguous non-whitespace region combinedKey = "w/b" description = "next WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "g b" priority = 1 name = "WORD ←" combinedName = "WORD →/←" description = "previous WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" -computedArgs.value = "-count || -1" +args.value = "{{-count || -1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "g e" priority = 1 name = "WORD end →" description = "next WORD end; e.g. contiguous non-whitespace region" args.unit = "BigWord" -computedArgs.boundary = "around_on ? 'both' : 'end'" -computedArgs.value = "count || 1" +args.boundary = "{{around_on ? 'both' : 'end'}}" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "g 0" priority = 1 name = "sec →" @@ -1061,38 +1044,36 @@ combinedName = "sec →/←" combinedDescription = "next/previous section" combinedKey = "0/9" args.unit = "section" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.obj" +merge = "{{edit_motion_obj}}" key = "g 9" priority = 1 name = "sec ←" description = "previous section" combinedName = "sec →/←" args.unit = "section" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "window" +merge = "{{window}}" name = "goto line" priority = 1 description = "goto line command" key = "g l" command = "workbench.action.gotoLine" -when = "editorTextFocus" [[bind]] -defaults = "window" +merge = "{{window}}" name = "to refs" priority = 1 description = "jump to a location where this symbol is referenced" key = "g r" command = "editor.action.goToReferences" -when = "editorTextFocus" [[bind]] -defaults = "window" +merge = "{{window}}" name = "go to" priority = 1 description = "go to the definition of symbol under cursor" @@ -1101,28 +1082,25 @@ combinedName = "go to (aside)" combinedKey = "(shift+)d" combinedDescription = "go to the definition of symbol (in an editor to the side)" command = "editor.action.revealDefinition" -when = "editorTextFocus" [[bind]] -defaults = "window" +merge = "{{window}}" name = "go to, aside" priority = 1 description = "go to the definition of symbol under cursor in an editor to the side" key = "g shift+d" combinedName = "go to (aside)" command = "editor.action.revealDefinitionAside" -when = "editorTextFocus" [[bind]] -defaults = "window" +merge = "{{window}}" name = "open" description = "open the file name under the cursor" key = "g f" command = "extension.openFileFromPath" -when = "editorTextFocus" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "g c" name = "cell →" combinedName = "cell →/←" @@ -1131,7 +1109,7 @@ args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] description = "previous jupyter notebook cell" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" key = "g shift+c" name = "cell ←" combinedName = "cell →/←" @@ -1145,18 +1123,15 @@ args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] # If you accidentally select `around` instead of `in`, you can revise your selection using `R` to narrow to non-white space or `z` to narrow to a subword (e.g. excludes `_`) -[[default]] -id = "edit.motion.match" - -[[default]] -id = "edit.motion.match.obj" -default.command = "selection-utilities.moveBy" -default.kind = "motion" -default.args.selectWhole = true -default.args.boundary = "start" +[define.edit_motion_match_obj] +merge = "{{edit_motion}}" +command = "selection-utilities.moveBy" +kind = "motion" +args.selectWhole = true +args.boundary = "start" [[bind]] -defaults = "edit.motion.match" +merge = "{{edit_motion}}" key = "m" name = "match" description = """ @@ -1166,14 +1141,14 @@ kind = "motion" command = "master-key.prefix" [[bind]] -defaults = "edit.motion.match" +merge = "{{edit_motion}}" key = "m m" name = "smart expand" description = "Use VSCode's built-in smart expansion command" command = "editor.action.smartSelect.expand" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m w" name = "around subwrd →" description = "(camel/snake case)" @@ -1181,177 +1156,174 @@ combinedName = "around subwrd ←/→" combinedDescription = "(camel/snake case)" combinedKey = "w/b" args.unit = "subword" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m b" name = "around subwrd ←" description = "(camel/snake case)" combinedName = "around subwrd ←/→" args.unit = "subword" -computedArgs.value = "-count || -1" +args.value = "{{-count || -1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+w" name = "ard word →" combinedName = "around word →/←" combinedKey = "shift+w/b" args.unit = "word" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+b" name = "ard word ←" combinedName = "around word →/←" args.unit = "word" -computedArgs.value = "-count || -1" +args.value = "{{-count || -1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m e" name = "in subwrd" combinedName = "in → subword/word" combinedKey = "e/shift+e" args.unit = "subident" args.boundary = "both" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+e" name = "in word" combinedName = "in → subword/word" args.unit = "word" args.boundary = "both" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m p" name = "in parag. →" combinedName = "in paragraph →/←" combinedKey = "p/o" args.boundary = "both" args.unit = "paragraph" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m o" name = "in parag. ←" combinedName = "in paragraph →/←" args.unit = "paragraph" args.boundary = "both" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+p" name = "arn parag. →" combinedName = "around paragraph →/←" combinedKey = "shift+p/shift+o" args.unit = "paragraph" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+o" name = "arn parag. ←" combinedName = "around paragraph →/←" args.unit = "paragraph" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m 0" name = "arn subsec →" combinedName = "around subsection →/←" combinedKey = "0/shift+0" args.unit = "subsection" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+0" name = "arn subsec ←" combinedName = "around subsection →/←" args.unit = "subsection" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m 9" name = "in subsec →" combinedName = "in subsection →/←" combinedKey = "9/shift+9" args.unit = "subsection" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m shift+9" name = "in subsec ←" combinedName = "in subsection →/←" args.unit = "subsection" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match" +merge = "{{edit_motion}}" key = "m g" name = "other..." description = "additional objects to match..." command = "master-key.prefix" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m g 0" name = "section →" combinedName = "section →/←" combinedKey = "0/9" args.unit = "section" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m g 9" name = "section ←" combinedName = "section →/←" args.unit = "section" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m g w" name = "around WORD →" combinedName = "around WORD →/←" combinedKey = "w/b" args.unit = "BigWord" -computedArgs.value = "count || 1" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m g b" name = "around WORD ←" combinedName = "around WORD →/←" args.unit = "BigWord" -computedArgs.value = "-(count || 1)" +args.value = "{{-(count || 1)}}" [[bind]] -defaults = "edit.motion.match.obj" +merge = "{{edit_motion_match_obj}}" key = "m g e" name = "in WORD" args.unit = "BigWord" args.boundary = "both" -computedArgs.value = "count || 1" - -[[default]] -id = "edit.motion.match.syntax" +args.value = "{{count || 1}}" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m [" name = "in parens" combinedName = "in/arnd parens" @@ -1367,7 +1339,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandWithinBrackets" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m shift+[" name = "arnd parens" combinedName = "in/arnd parens" @@ -1378,7 +1350,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandAroundBrackets" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m '" name = "in quotes" description = """ @@ -1394,7 +1366,7 @@ will seek out larger and larger scopes command = "bracketeer.selectQuotesContent" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m shift+'" name = "around quotes" combinedName = "in/arnd quotes" @@ -1406,7 +1378,7 @@ command = "runCommands" args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesContent"] [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m shift+." name = "in <>" description = "text inside angle brackets" @@ -1416,7 +1388,7 @@ combinedDescription = "text inside angle brackets / pairs (e.g. text in text< command = "extension.selectAngleBrackets" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m shift+," name = "in ><" combinedName = "in <> / in ><" @@ -1424,7 +1396,7 @@ description = "text inside tag pairs (e.g. text)" command = "extension.selectInTag" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m i" name = "in indent" description = "all text at the same indentation level" @@ -1437,7 +1409,7 @@ below this (ala c-like syntax) command = "vscode-select-by-indent.select-inner" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m shift+i" name = "arnd indent" description = """ @@ -1448,7 +1420,7 @@ combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer" [[bind]] -defaults = "edit.motion.match.syntax" +merge = "{{edit_motion}}" key = "m g i" name = "indent+top" description = """ @@ -1457,21 +1429,15 @@ all text at the same indentation level and the line just above it (ala python sy combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer-top-only" -[[default]] -id = "edit.motion.match.cell" - [[bind]] -defaults = "edit.motion.match.cell" +merge = "{{edit_motion}}" name = "in cell" description = "select text within a cell (ala jupyter)" key = "m c" command = "jupyter.selectCell" -[[default]] -id = "edit.motion.searchpair" - [[bind]] -defaults = "edit.motion.searchpair" +merge = "{{edit_motion}}" name = "between pair" combinedDescription = """ Select between pairs of the same N characters (t) or distinct sets of N @@ -1490,15 +1456,15 @@ Example: 2mt'' would search for a string between '' and ''. [[bind.args.commands]] command = "master-key.captureKeys" -computedArgs.acceptAfter = "count || 1" +args.acceptAfter = "{{count || 1}}" [[bind.args.commands]] command = "selection-utilities.selectBetween" -computedArgs.str = "captured" +args.str = "{{captured}}" args.inclusive = false [[bind]] -defaults = "edit.motion.searchpair" +merge = "{{edit_motion}}" name = "between two" description = """ Select between two different sets of N characters, where N is the count e.g. @@ -1510,12 +1476,12 @@ command = "runCommands" [[bind.args.commands]] command = "master-key.captureKeys" -computedArgs.acceptAfter = "2*(count || 1)" +args.acceptAfter = "{{2*(count || 1)}}" [[bind.args.commands]] command = "selection-utilities.selectBetween" -computedArgs.between.from = "captured.slice(0, captured.length/2)" -computedArgs.between.to = "captured.slice(captured.length/2)" +args.between.from = "{{captured.slice(0, captured.length/2)}}" +args.between.to = "{{captured.slice(captured.length/2)}}" args.inclusive = false # ## Simple Actions @@ -1523,16 +1489,13 @@ args.inclusive = false # These are the most common, basic actions available in Larkin that can be used # to edit text in relation to the current selection. -[[default]] -id = "edit.action" -default.kind = "action" -default.mode = "normal" - -[[default]] -id = "edit.action.basic" +[define.edit_action] +kind = "action" +mode = "normal" +tags = ["action"] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" #- TODO: add documentation to these basic editor keys key = "i" name = "insert" @@ -1542,7 +1505,7 @@ args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] mode = ["normal", "selectedit", "syminsert"] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "a" name = "append" description = "insert after cursor" @@ -1555,7 +1518,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "shift+i" name = "insert start" mode = ["normal", "selectedit", "syminsert"] @@ -1566,7 +1529,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "shift+a" name = "insert end" mode = ["normal", "selectedit", "syminsert"] @@ -1577,7 +1540,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "c" name = "change" description = """ @@ -1589,14 +1552,14 @@ command = "runCommands" args.commands = ["deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "c" when = "!editorHasMultilineSelection && editorHasSelection" command = "runCommands" args.commands = ["deleteRight", "master-key.enterInsert"] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "c" when = "!editorHasSelection && master-key.count <= 1" command = "runCommands" @@ -1608,7 +1571,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "c" when = "!editorHasSelection && master-key.count > 1" command = "runCommands" @@ -1620,7 +1583,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "shift+c" name = "change to/back" description = """Without a count: change from current char to end of line. With a count: @@ -1636,7 +1599,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "shift+c" mode = ["normal", "selectedit"] when = "master-key.count > 1" @@ -1649,37 +1612,34 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.basic" -key = "x" -mode = "normal" -name = "delete char" -command = "runCommands" +merge = "{{edit_action}}" args.commands = [ "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "right", select = true }, computedArgs = { value = "count" } }, + { command = "cursorMove", args = { to = "right", select = true, value = "{{count}}" } }, "editor.action.clipboardCutAction", ] +key = "x" +mode = "normal" +name = "delete char" +command = "runCommands" [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "r" name = "replace char" description = "replace the character under the cursor" command = "master-key.replaceChar" [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "ctrl+i" name = "insert char" mode = ["normal", "selectedit"] description = "insert a character in front of the cursor" command = "master-key.insertChar" -[[default]] -id = "edit.action.clipboard" - [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "p" name = "paste after" description = "Paste clipboard after the cursor/selection" @@ -1695,7 +1655,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "p" name = "paste after" combinedName = "paste before/after/in" @@ -1704,7 +1664,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" mode = ["normal", "insert"] @@ -1714,7 +1674,7 @@ description = "Paste clipboard at location" command = "editor.action.clipboardPasteAction" [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+p" name = "paste before" combinedName = "paste before/after" @@ -1728,7 +1688,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+p" combinedName = "paste before/after" when = "!editorHasSelection" @@ -1736,7 +1696,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "repeat action" description = """ Repeat the last action command. Actions usually modify the text of a document in one way or @@ -1745,7 +1705,7 @@ See also `,` which repeats the last subject. """ key = "." command = "runCommands" -computedRepeat = "count" +computedRepeat = "{{count}}" [[bind.args.commands]] command = "master-key.replayFromHistory" @@ -1753,35 +1713,35 @@ command = "master-key.replayFromHistory" args.at = """ commandHistory[i].path.startsWith('edit.action') && (!commandHistory[i].path.startsWith('edit.action.history') || - commandHistory[i].name == 'replay') +commandHistory[i].name == 'replay') """ [[bind.args.commands]] command = "master-key.enterNormal" [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "undo" key = "u" command = "runCommands" args.commands = ["undo", "selection-utilities.shrinkToActive"] [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "redo" key = "shift+u" command = "runCommands" args.commands = ["redo", "selection-utilities.shrinkToActive"] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" name = 'toggle check' description = "Toggle a markdown checkbox" key = "shift+6" command = "markdown-checkbox.markCheckbox" [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "d" name = "delete" description = """ @@ -1797,7 +1757,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "d" when = "editorHasSelection" command = "runCommands" @@ -1807,7 +1767,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+d" mode = "normal" name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." @@ -1819,7 +1779,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+d" mode = "normal" when = "master-key.count > 1" @@ -1827,7 +1787,7 @@ command = "runCommands" args.commands = [{ defined = "selectLinesUp" }, "deleteRight"] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "y" name = "copy" description = "copy selected text to clipboard" @@ -1835,7 +1795,7 @@ command = "runCommands" args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "y" when = "master-key.count > 1" command = "runCommands" @@ -1846,7 +1806,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+y" name = "copy (eol/up)" description = "without a count: copy to end of line; with a count: copy this and the previous N lines" @@ -1860,7 +1820,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.clipboard" +merge = "{{edit_action}}" key = "shift+y" when = "master-key.count > 1" command = "runCommands" @@ -1870,21 +1830,15 @@ args.commands = [ "selection-utilities.shrinkToActive", ] -[[default]] -id = "edit.action.open_lines" - -[[default]] -id = "edit.action.indent" - [[bind]] -defaults = "edit.action.indent" +merge = "{{edit_action}}" key = "shift+." name = "indent" description = "Indent lines" command = "editor.action.indentLines" [[bind]] -defaults = "edit.action.indent" +merge = "{{edit_action}}" key = "shift+." name = "indent" description = "Indent lines" @@ -1893,7 +1847,7 @@ command = "runCommands" args.commands = [{ defined = "selectLinesDown" }, "editor.action.indentLines"] [[bind]] -defaults = "edit.action.indent" +merge = "{{edit_action}}" key = "shift+," name = "deindent" when = "master-key.count < 1" @@ -1901,7 +1855,7 @@ description = "De-indent lines" command = "editor.action.outdentLines" [[bind]] -defaults = "edit.action.indent" +merge = "{{edit_action}}" key = "shift+," name = "deindent" when = "master-key.count >= 1" @@ -1913,25 +1867,23 @@ args.commands = [ "selection-utilities.shrinkToActive", ] -[[default]] -id = "edit.action.history" +[define.edit_action_history] +merge = "{{edit_action}}" +tags = ["history"] # ## Number actions # These commands modify or enter numbers in some way. -[[default]] -id = "edit.action.numbers" - [[bind]] -defaults = "edit.action.numbers" +merge = "{{edit_action}}" name = 'inc #' description = "Increment a number by 1" key = "=" command = "selection-utilities.incrementNumber" [[bind]] -defaults = "edit.action.numbers" +merge = "{{edit_action}}" name = 'dec #' description = "Decrement a number by 1 " key = "shift+=" @@ -1941,103 +1893,103 @@ command = "selection-utilities.decrementNumber" # These modify the capitalization of letters in some way. -[[default]] -id = "edit.action.capitals" -default.mode = ["normal", "selectedit"] +[define.edit_action_capitals] +merge = "{{edit_action}}" +mode = ["normal", "selectedit"] [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'camel' description = "Swap style to lower camel case (`camelCase`)" key = "` c" command = "extension.changeCase.camel" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'constant' description = "Swap style to constant (`IS_CONSTANT`)" key = "` shift+u" command = "extension.changeCase.constant" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'dot' description = "Swap style to dot case (`dot.case`)" key = "` ." command = "extension.changeCase.dot" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'kebab' description = "Swap style to kebab case (`kebab-case`)" key = "` -" command = "extension.changeCase.kebab" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'all lower' description = "Swap all to lower case" key = "` shift+l" command = "extension.changeCase.lower" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'first lower' description = "Swap first letter to lower case" key = "` l" command = "extension.changeCase.lowerFirst" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'spaces' description = "Swap to spaces (`camelCase` -> `camel case`)" key = "` space" command = "extension.changeCase.no" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'Camel' description = "Swap to upper camel case (`CamelCase`)" key = "` shift+c" command = "extension.changeCase.pascal" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'path' description = "Swap to 'path' case (`path/case`)" key = "` /" command = "extension.changeCase.path" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'snake' description = "Swap to snake case (`snake_case`)" key = "` shift+-" command = "extension.changeCase.snake" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'swap' description = "Swap upper and lower case letters" key = "` s" command = "extension.changeCase.swap" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'title' description = "Swap to title case (all words have first upper case letter)" key = "` t" command = "extension.changeCase.title" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'all upper' description = "Swap to use all upper case letters" key = "` shift+y" command = "extension.changeCase.upper" [[bind]] -defaults = "edit.action.capitals" +merge = "{{edit_action_capitals}}" name = 'first upper' description = "Swap first character to upper case" key = "` u" @@ -2047,19 +1999,15 @@ command = "extension.changeCase.upperFirst" # These keys are all organized under the `space` key and they "do" something. These are generally more elaborate editing operations in the current editor pane. -[[default]] -id = "edit.action.do" -default.mode = "normal" - [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = "do" key = "space" description = "additional actions, mostly for modifying specific syntactic formats" command = "master-key.prefix" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = "paste after line" combinedName = "paste after/before line" combinedKey = "p/shift+p" @@ -2075,7 +2023,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" priority = 2 name = "paste before line" combinedName = "paste after/before line" @@ -2090,7 +2038,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" priority = 2 name = "add line below" combinedName = "add line below/above" @@ -2101,7 +2049,7 @@ key = "space o" command = "editor.action.insertLineAfter" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = "add line above" priority = 2 combinedName = "add line below/above" @@ -2110,7 +2058,7 @@ key = "space shift+o" command = "editor.action.insertLineBefore" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'sym insert' description = "Insert a character pair around a character" priority = 1 @@ -2126,19 +2074,19 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -computedArgs.before = "braces[captured].before || captured" -computedArgs.after = "braces[captured].after || captured" +args.before = "{{braces[captured].before || captured}}" +args.after = "{{braces[captured].after || captured}}" args.followCursor = true [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'trim white' description = "Delete all external whitespace (left and right edges)" key = "space shift+-" command = "selection-utilities.trimWhitespace" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space w" name = "wrap p" combinedName = "wrap/join lines" @@ -2148,7 +2096,7 @@ combinedKey = "w/j" command = "rewrap.rewrapComment" [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" name = 'join' combinedName = "wrap/join lines" description = "Remove newline between current and next line" @@ -2159,7 +2107,7 @@ command = "runCommands" args.commands = [{ defined = "selectLinesDown" }, 'editor.action.joinLines'] [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" combinedName = "wrap/join lines" name = 'join' description = "Remove newline between current and next line" @@ -2168,7 +2116,7 @@ key = "space j" command = "editor.action.joinLines" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space f" name = "format" combinedName = "format / format document" @@ -2176,7 +2124,7 @@ when = "master-key.count < 1" command = "editor.action.formatSelection" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space f" combinedName = "format / format document" combinedKey = "f/shift+f" @@ -2192,69 +2140,63 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space shift+f" name = "format doc" combinedName = "format / format document" command = "editor.action.formatDocument" -[[default]] -id = "edit.action.brackets" - [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'parens' description = "actions related to various brackets (`[`, `(`, `{`)" key = "space [" command = "master-key.prefix" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'remove' description = "Removes surrounding pairs" key = "space [ d" command = "bracketeer.removeBrackets" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'parens/brackets' description = "Swap between `[`, `(` and `{`" key = "space [ s" command = "bracketeer.swapBrackets" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'quotes' description = "Actions related to quotes" key = "space '" command = "master-key.prefix" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'remove' description = "Removes quotes (', \" or `)" key = "space ' d" command = "bracketeer.removeQuotes" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'swap' description = "Swap quotes (', \" or `)" key = "space ' s" command = "bracketeer.swapQuotes" -[[default]] -id = "edit.action.comment" - [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space /" combinedName = "(block) comment" when = "master-key.count < 1" command = "editor.action.commentLine" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space /" name = "comment lines" combinedName = "(block) comment" @@ -2266,14 +2208,14 @@ command = "runCommands" args.commands = [{ defined = "selectLinesDown" }, "editor.action.commentLine"] [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space shift+/" when = "master-key.count < 1" combinedName = "(block) comment" command = "editor.action.blockComment" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space shift+/" name = "block comment lines" combinedName = "(block) comment" @@ -2287,7 +2229,7 @@ args.commands = [ ] [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'inc all #' combinedName = "inc/dec all #" combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" @@ -2297,7 +2239,7 @@ key = "space =" command = "selection-utilities.incrementNumberPerSelection" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'dec all #' combinedName = "inc/dec all #" description = "Decrement selected numbers; decrement increases per selection" @@ -2305,14 +2247,14 @@ key = "space shift+=" command = "selection-utilities.decrementNumberPerSelection" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" name = 'nb cell' description = "Actions related to notebook cells" key = "space c" command = "master-key.prefix" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space c i" when = "editorLangId == 'quarto'" command = "quarto.insertCodeCell" @@ -2320,13 +2262,13 @@ name = "insert cell" description = "insert a new cell in a notebook" [[bind]] -defaults = "edit.action.do" +merge = "{{edit_action}}" key = "space c s" when = "editorLangId != 'quarto'" command = "jupyter.selectCell" [[bind]] -defaults = "edit.action.basic" +merge = "{{edit_action}}" key = "space ." name = 'sent. lines' description = "Split paragraph into one line per sentence" @@ -2364,7 +2306,7 @@ command = "selection-utilities.cancelSelection" # These commands interact with the history of previously typed commands to repeat some sequence of commands. They can record any edits, and any commands that are issued through master key bindings. Commands that are not part of this binding file (e.g. a standard call to Cmd/Ctrl+V to paste) will not be recorded. You can copy your non-master-key bindings over to master key (so that they will be recorded) by [customizing your bindings](#customized-bindings) and using `Import Default Bindings` and `Import User Bindings` to allow all of the default and user bindings stored in VSCOde's normal keybinding files to be recorded by master key. (You will have to remove your original user bindings from the VSCOde `keybinding.json` file manually) [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "record" description = "Start/stop recording Master Key commands" key = "shift+q" @@ -2373,7 +2315,7 @@ command = "master-key.record" args.on = true [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "record" description = """ Start/stop recording key presses defined by Master Key pushing it to the @@ -2393,7 +2335,7 @@ args.whereComputedRangeIs.from = 'commandHistory[index-1].name === "record"' args.whereComputedRangeIs.to = "index" [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "replay" description = """ Replay the Master Key command sequence at the top of the `history` stack. Specifying @@ -2401,10 +2343,10 @@ a count requests the Nth most recent item on this stack. """ key = "q q" command = "master-key.replayFromStack" -computedArgs.index = "count" +args.index = "{{count}}" [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "store macro" description = """ Stores the top of the `history` stack into a named register. Specifying a count stores the @@ -2417,7 +2359,7 @@ args.register = "macro" args.contents = "macro[macro.length-(count || 0)-1]" [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "replay stored" description = """ Replay a recorded Master Key command sequence from a named register, pushing @@ -2433,14 +2375,14 @@ args.register = "macro" [[bind.args.commands]] command = "master-key.pushHistoryToStack" -computedArgs.value = "captured" +args.value = "{{captured}}" [[bind.args.commands]] command = "master-key.replayFromStack" args.index = 0 [[bind]] -defaults = "edit.action.history" +merge = "{{edit_action_history}}" name = "store last" description = """ Store the N most recently run commands as a macro, where N is the count (defaulting to 1). @@ -2455,7 +2397,7 @@ args.whereComputedRangeIs.to = "index" # These actions include miscellaneous utilities. [[bind]] -defaults = "window" +merge = "{{window}}" key = "shift+ctrl+;" name = "palette" finalKey = false @@ -2469,14 +2411,14 @@ show command suggestions within the context of the current mode and keybinding p command = "master-key.commandPalette" [[bind]] -defaults = "util" +merge = "{{util}}" name = "git..." description = "git commands" key = "tab g" command = "master-key.prefix" [[bind]] -defaults = "util" +merge = "{{util}}" name = "pull" combinedName = "push/pull" description = "pull changes from remote" @@ -2486,14 +2428,14 @@ key = "tab g p" command = "git.pull" [[bind]] -defaults = "util" +merge = "{{util}}" name = "push" description = "push changes to remote" key = "tab g shift+p" command = "git.push" [[bind]] -defaults = "util" +merge = "{{util}}" name = "checkout" combinedName = "commit/checkout" description = "commit changes" @@ -2503,7 +2445,7 @@ key = "tab g c" command = "git.commit" [[bind]] -defaults = "util" +merge = "{{util}}" name = "checkout" combinedName = "commit/checkout" description = "checkout changes" @@ -2511,21 +2453,21 @@ key = "tab g shift+c" command = "git.checkout" [[bind]] -defaults = "util" +merge = "{{util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g r" command = "git.revertSelectedRanges" [[bind]] -defaults = "util" +merge = "{{util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g s" command = "git.stageSelectedRanges" [[bind]] -defaults = "util" +merge = "{{util}}" name = "commands..." description = "show GitLens command palette for git" key = "tab g g" @@ -2535,26 +2477,25 @@ command = "gitlens.gitCommands" # These miscellaneous utility commands are all organized uner the prefix `tab`. -[[default]] -id = "util" -appendWhen = "editorTextFocus && !findWidgetVisible" +[define.util] +when = "editorTextFocus && !findWidgetVisible" [[bind]] -defaults = "util" +merge = "{{util}}" name = "utility" key = "tab" description = "utility related commands: file opening, window manipulation, debugging etc..." command = "master-key.prefix" [[bind]] -defaults = "util" +merge = "{{util}}" name = "open recent" description = "Open recent file" key = "tab r" command = "workbench.action.openRecent" [[bind]] -defaults = "util" +merge = "{{util}}" name = "hover" description = "show the hover view" combinedName = "(debug) hover" @@ -2564,7 +2505,7 @@ key = "tab h" command = "editor.action.showHover" [[bind]] -defaults = "util" +merge = "{{util}}" name = "debug hover" combinedName = "(debug) hover" description = "show the debug hover view" @@ -2572,7 +2513,7 @@ key = "tab shift+h" command = "editor.debug.action.showDebugHover" [[bind]] -defaults = "util" +merge = "{{util}}" name = "add mark" combinedName = "add mark / mark..." description = "toggle bookmark at given line" @@ -2584,7 +2525,7 @@ combinedKey = "shift+m / m" command = "vsc-labeled-bookmarks.toggleBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" name = "mark" combinedName = "add mark / mark..." description = "bookmark related commands" @@ -2592,7 +2533,7 @@ key = "tab m" command = "master-key.prefix" [[bind]] -defaults = "util" +merge = "{{util}}" name = "mark ↓" description = "move to next bookmark" combinedName = "mark ↓/↑" @@ -2603,14 +2544,14 @@ when = "!master-key.select_on && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" combinedName = "mark ↓/↑" key = "tab m j" when = "master-key.select_on || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" @@ -2619,7 +2560,7 @@ when = "!master-key.select_on && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" @@ -2632,21 +2573,21 @@ args.commands = [ ] [[bind]] -defaults = "util" +merge = "{{util}}" name = "remove mark" description = "remove bookmark (use quick selection)" key = "tab m d" command = "vsc-labeled-bookmarks.deleteBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" name = "nav marks" description = "reveal quick selection to move to a bookmark" key = "tab m t" command = "vsc-labeled-bookmarks.navigateToBookmark" [[bind]] -defaults = "util" +merge = "{{util}}" name = "error →" combinedName = "error →/←" combinedDescription = "move to next/previous error" @@ -2658,7 +2599,7 @@ key = "tab e" command = "editor.action.marker.next" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = "error ←" combinedName = "error →/←" description = """ @@ -2668,7 +2609,7 @@ key = "tab shift+e" command = "editor.action.marker.prev" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = "diff →" combinedName = "diff →/←" combinedDescription = "move to and show next/previous diff" @@ -2680,7 +2621,7 @@ key = "tab c" command = "editor.action.dirtydiff.next" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = "diff ←" combinedName = "diff →/←" description = """ @@ -2690,7 +2631,7 @@ key = "tab shift+c" command = "editor.action.dirtydiff.previous" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = "change →" combinedName = "change →/←" combinedDescription = "move to next/previous file change" @@ -2702,7 +2643,7 @@ key = "tab d" command = "workbench.action.editor.nextChange" [[bind]] -defaults = "edit.motion" +merge = "{{edit_motion}}" name = "change ←" combinedName = "change →/←" description = """ @@ -2715,37 +2656,35 @@ command = "workbench.action.editor.previousChange" # These are commands that interact with VSCode's user-interface in some way, rather than editing or moving around in the editor pane. -[[default]] -id = "window" -default.kind = "util" -default.mode = "normal" -appendWhen = "editorTextFocus && !findWidgetVisible" +[define.window] +kind = "util" +mode = "normal" +when = "editorTextFocus && !findWidgetVisible" [[bind]] -defaults = "window" +merge = "{{window}}" name = "cntr win" description = "center window at primary cursor position" key = "tab l" command = "selection-utilities.revealActive" args.at = "center" -when = "editorTextFocus" [[bind]] -defaults = "window" +merge = "{{window}}" name = "window" description = "window/editor pane manipulation-related commands" key = "tab w" command = "master-key.prefix" [[bind]] -defaults = "window" +merge = "{{window}}" name = "vert/horz" key = "tab w r" description = "Toggle between horizontal and vertical layouts" command = "workbench.action.toggleEditorGroupLayout" [[bind]] -defaults = "window" +merge = "{{window}}" name = "next window" combinedName = "next/previous window" description = "move to next window" @@ -2755,7 +2694,7 @@ combinedKey = "]/[" command = "workbench.action.focusNextGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "prev window" combinedName = "next/previous window" description = "move to previous window" @@ -2763,7 +2702,7 @@ key = "tab [" command = "workbench.action.focusPreviousGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "move →" combinedName = "move →/←" combinedDescription = "move editor to window left/right" @@ -2773,7 +2712,7 @@ key = "tab w l" command = "workbench.action.moveEditorToRightGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "←" combinedName = "move →/←" description = "move editor to window to left" @@ -2781,7 +2720,7 @@ key = "tab w h" command = "workbench.action.moveEditorToLeftGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "↓" combinedName = "move ↓/↑" combinedDescription = "move editor to window above/below" @@ -2791,7 +2730,7 @@ key = "tab w j" command = "workbench.action.moveEditorToBelowGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "↑" combinedName = "move ↓/↑" description = "move editor to window above" @@ -2799,14 +2738,14 @@ key = "tab w k" command = "workbench.action.moveEditorToAboveGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "split editor..." description = "split editor to in a given direction" key = "tab w s" command = "master-key.prefix" [[bind]] -defaults = "window" +merge = "{{window}}" name = "move →" combinedName = "split →/←" combinedDescription = "move editor to window left/right" @@ -2816,7 +2755,7 @@ key = "tab w s l" command = "workbench.action.splitEditorRight" [[bind]] -defaults = "window" +merge = "{{window}}" name = "←" combinedName = "split →/←" description = "split editor to window to left" @@ -2824,7 +2763,7 @@ key = "tab w s h" command = "workbench.action.splitEditorLeft" [[bind]] -defaults = "window" +merge = "{{window}}" name = "↓" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2834,7 +2773,7 @@ key = "tab w s j" command = "workbench.action.splitEditorDown" [[bind]] -defaults = "window" +merge = "{{window}}" name = "↑" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2844,28 +2783,28 @@ key = "tab w s k" command = "workbench.action.splitEditorUp" [[bind]] -defaults = "window" +merge = "{{window}}" name = "close pane" description = "close the given group of editors" key = "tab w x" command = "workbench.action.closeEditorsInGroup" [[bind]] -defaults = "window" +merge = "{{window}}" name = "max" description = "minimize size of all other windows" key = "tab w shift+m" command = "workbench.action.minimizeOtherEditors" [[bind]] -defaults = "window" +merge = "{{window}}" name = "equal" description = "equalize size of all windows" key = "tab w =" command = "workbench.action.evenEditorWidths" [[bind]] -defaults = "window" +merge = "{{window}}" name = "curs. win top" description = "center window so that primary cursor is at the top" key = "tab k" @@ -2876,7 +2815,7 @@ command = "selection-utilities.revealActive" args.at = "top" [[bind]] -defaults = "window" +merge = "{{window}}" name = "curs. win bot" combinedName = "center window top/bottom" description = "center window so that primary cursor is at the bottom" @@ -2889,7 +2828,7 @@ args.at = "bottom" # Commands for interacting with VSCode's debugger UI. [[bind]] -defaults = "util" +merge = "{{util}}" name = "breakpt." combinedName = "breakpt / debug..." combinedKey = "shift+b/b" @@ -2899,7 +2838,7 @@ key = "tab shift+b" command = "editor.debug.action.toggleBreakpoint" [[bind]] -defaults = "util" +merge = "{{util}}" name = "debug..." combinedName = "breakpt / debug..." description = "assorted debugging actions" @@ -2907,7 +2846,7 @@ key = "tab b" command = "master-key.prefix" [[bind]] -defaults = "util" +merge = "{{util}}" name = "cond. break" description = "conditional breakpoint" key = "tab b shift+c" @@ -2915,35 +2854,35 @@ command = "editor.debug.action.conditionalBreakpoint" [[bind]] -defaults = "util" +merge = "{{util}}" name = "start" description = "start debugging" key = "tab b r" command = "workbench.action.debug.start" [[bind]] -defaults = "util" +merge = "{{util}}" name = "continue" description = "continue debugging" key = "tab b c" command = "workbench.action.debug.continue" [[bind]] -defaults = "util" +merge = "{{util}}" name = "next" description = "debug: step over next line" key = "tab b j" command = "workbench.action.debug.stepOver" [[bind]] -defaults = "util" +merge = "{{util}}" name = "into" description = "debug: step into next line" key = "tab b i" command = "workbench.action.debug.stepInto" [[bind]] -defaults = "util" +merge = "{{util}}" name = "out" description = "debug: step out" key = "tab b o" @@ -2958,13 +2897,12 @@ command = "workbench.action.debug.stepOut" # - save a single selection to a list of selections to use for later and # then move the cursor to the next selection you wish to add -[[default]] -id = "edit.select_edit" -default.mode = "selectedit" -default.kind = "motion" +[define.edit_select_edit] +mode = "selectedit" +kind = "motion" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "select-edit" description = """ Enter a mode where you can edit and manipulate (possibly multiple) selections. @@ -2975,7 +2913,7 @@ args.value = "selectedit" mode = "normal" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" key = "shift+'" combinedName = "rm cursors" combinedKey = "shift/ctrl+'" @@ -2987,7 +2925,7 @@ args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal" mode = ["selectedit", "normal"] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" key = "ctrl+'" mode = ["insert", "selectedit", "normal"] name = "rm cursors" @@ -2997,34 +2935,34 @@ command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = 'normal' description = "return to normal mode" key = "'" command = "master-key.enterNormal" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "add →" combinedName = "add →/←" description = "add cursor at the next match to the primary cursor's text" combinedDescription = "add cursor at the next/previous match to the primary cursor's text" key = "l" combinedKey = "l/h" -computedRepeat = "count" +computedRepeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "add ←" combinedName = "add →/←" description = "add cursor at the previous match to the primary cursor's text" key = "h" command = "selection-utilities.addPrev" -computedRepeat = 'count' +computedRepeat = '{{count}}' [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "skip →" combinedName = "skip →/←" description = "move primary cursor to the next match of the primary cursor's text" @@ -3032,33 +2970,33 @@ combinedDescription = "move primary cursor to the next/previous match of the pri key = "shift+l" combinedKey = "shift+l/h" command = "selection-utilities.skipNext" -computedRepeat = "count" +computedRepeat = "{{count}}" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "skip ←" combinedName = "skip →/←" description = "move primary cursor to the previous match of the primary cursor's text" key = "shift+h" command = "selection-utilities.skipPrev" -computedRepeat = 'count' +computedRepeat = '{{count}}' [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "align ←" description = "align selections left" key = "=" command = "selection-utilities.alignSelectionsLeft" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "align →" description = "align selections right" key = "shift+=" command = "selection-utilities.alignSelectionsRight" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "→ sel" combinedName = "→/← sel" description = """ @@ -3072,19 +3010,19 @@ what cursor you delete, and where the cursor goes when you clear or save selecti key = "j" combinedKey = "j/l" command = "selection-utilities.movePrimaryRight" -computedRepeat = 'count' +computedRepeat = '{{count}}' [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "← sel" combinedName = "→/← sel" description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" key = "k" command = "selection-utilities.movePrimaryLeft" -computedRepeat = 'count' +computedRepeat = '{{count}}' [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "insert ↑" combinedName = "insert ↑/↓" description = """ @@ -3094,10 +3032,10 @@ combinedDescription = "insert cursor on line above/below" key = "shift+k" combinedKey = "shift+k/j" command = "editor.action.insertCursorAbove" -computedRepeat = "count" +computedRepeat = "{{count}}" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "insert sel ↓" combinedName = "insert ↑/↓" description = """ @@ -3105,10 +3043,10 @@ insert cursor on line below """ key = "shift+j" command = "editor.action.insertCursorBelow" -computedRepeat = "count-1" +computedRepeat = "{{count-1}}" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "del. primary" combinedName = "del. primary/others" description = "remove the primary selection" @@ -3118,17 +3056,17 @@ mode if all selections are deleted. """ key = "d" command = "selection-utilities.deletePrimary" -computedRepeat = "count-1" +computedRepeat = "{{count-1}}" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = 'del. others' description = "delete all other cursors but the primary selection" key = "shift+d" command = "removeSecondaryCursors" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "save sel" description = """ save all selections to the default register. @@ -3137,13 +3075,13 @@ Use a count to specify an alternate register key = "c" command = "runCommands" args.commands = [ - { command = "selection-utilities.appendToMemory", computedArgs = { register = "count || 'default'" } }, + { command = "selection-utilities.appendToMemory", args = { register = "count || 'default'" } }, "selection-utilities.shrinkToActive", "master-key.enterNormal", ] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "load sel" description = """ load previously saved selections in the default register. @@ -3152,11 +3090,11 @@ Use a count to specify an alternate register key = "v" command = "runCommands" args.commands = [ - { command = "selection-utilities.restoreAndClear", computedArgs = { register = "count || 'default'" } }, + { command = "selection-utilities.restoreAndClear", args = { register = "count || 'default'" } }, ] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "exchange sel" description = """ exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. @@ -3164,12 +3102,12 @@ exchange selections: with no saved selection, saves the selection, with saved se key = "x" command = "runCommands" args.commands = [ - { command = "selection-utilities.swapWithMemory", computedArgs = { register = "count || 'default'" } }, + { command = "selection-utilities.swapWithMemory", args = { register = "count || 'default'" } }, "master-key.enterNormal", ] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "rem saved sel" description = """ remove the most recently saved selection from the list of saved selections @@ -3177,12 +3115,12 @@ remove the most recently saved selection from the list of saved selections command = "runCommands" key = "n" args.commands = [ - { command = "selection-utilities.deleteLastSaved", computedArgs = { register = "count || 'default'" } }, + { command = "selection-utilities.deleteLastSaved", args = { register = "count || 'default'" } }, "master-key.enterNormal", ] [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" key = "shift+enter" name = "split sel" description = """ @@ -3191,7 +3129,7 @@ split selection into multiple selections by new line charactesr command = "selection-utilities.splitByNewline" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "sel all" description = """ create a selection for every match of the current word (or selection) @@ -3200,7 +3138,7 @@ key = "shift+8" command = "editor.action.selectHighlights" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "character" description = "split by a given character" key = "s" @@ -3212,17 +3150,17 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.splitBy" -computedArgs.text = "captured" +args.text = "{{captured}}" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "string" description = "split by a given string" key = "shift+s" command = "selection-utilities.splitBy" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "include" description = """ Include all selections that contain a given marker @@ -3231,7 +3169,7 @@ key = "f" command = "selection-utilities.includeBy" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "exclude" description = """ Exclude all selections that contain a given marker @@ -3240,49 +3178,49 @@ key = "shift+f" command = "selection-utilities.excludeBy" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "create" description = "create selections of given string scoped to the current selections" key = "/" command = "selection-utilities.createBy" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "regex" description = "operations by regex rather than string" key = "r" command = "master-key.prefix" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "split" description = "split by a given regular expression" key = "r shift+s" command = "selection-utilities.splitByRegex" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "create" description = "create selections of given regular expression scoped to the current selections" key = "r /" command = "selection-utilities.createByRegex" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "include" description = "Include all selections that contain a given regular expression" key = "r f" command = "selection-utilities.includeByRegex" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "exclude" description = "Exclude all selections that contain a given regular expression" key = "r shift+f" command = "selection-utilities.excludeByRegex" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3292,7 +3230,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -defaults = "edit.select_edit" +merge = "{{edit_select_edit}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3334,22 +3272,20 @@ cursorShape = "BlockOutline" [[mode.onType]] command = "selection-utilities.insertAround" -computedArgs.before = "braces[captured].before || captured" -computedArgs.after = "braces[captured].after || captured" +args.before = "{{braces[captured].before || captured}}" +args.after = "{{braces[captured].after || captured}}" args.followCursor = true -[[default]] -id = "edit.action.symmetric" -default.kind = "action" -default.mode = "syminsert" +[define.edit_action_symmetric] +kind = "action" +mode = "syminsert" -[[default]] -id = "edit.motion.symmetric" -default.kind = "motion" -default.mode = "syminsert" +[define.edit_motion_symmetric] +kind = "motion" +mode = "syminsert" [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" name = "sym insert mode" priority = 1 description = """ @@ -3363,7 +3299,7 @@ command = "master-key.setMode" args.value = "syminsert" [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" name = "Normal" description = "Return to normal model" key = "enter" @@ -3371,7 +3307,7 @@ command = "master-key.setMode" mode = "syminsert" [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" foreach.key = ["{{key: [a-z]}}", "shift+{{key: [a-z]}}"] name = "" description = "this key is ignored and has no associated command in syminsert mode" @@ -3383,7 +3319,7 @@ hideInPalette = true [[bind]] name = "esc. char" -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" key = "\\" description = "Insert escaped character" command = "runCommands" @@ -3394,12 +3330,12 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -computedArgs.before = "'\\\\' + (braces[captured].before || captured)" -computedArgs.after = "'\\\\' + (braces[captured].after || captured)" +args.before = "{{'\\\\' + (braces[captured].before || captured)}}" +args.after = "{{'\\\\' + (braces[captured].after || captured)}}" args.followCursor = true [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" name = "delete" key = "x" description = """ @@ -3408,29 +3344,29 @@ delete the first and last character *in* the selection when cursor is at the sta selection """ command = "selection-utilities.deleteAround" -computedArgs.count = "count" +args.count = "{{count}}" args.followCursor = true [[bind]] -defaults = "edit.motion.symmetric" +merge = "{{edit_motion_symmetric}}" key = "l" name = "sel →" description = "shrink/grow selections in direction that's rightwards from cursor" command = "selection-utilities.adjustSelections" args.dir = "forward" -computedArgs.count = "count" +args.count = "{{count}}" [[bind]] -defaults = "edit.motion.symmetric" +merge = "{{edit_motion_symmetric}}" key = "h" name = "sel ←" description = "shrink/grow selections in direction that's leftwards from cursor" command = "selection-utilities.adjustSelections" args.dir = "backward" -computedArgs.count = "count" +args.count = "{{count}}" [[bind]] -defaults = "edit.motion.symmetric" +merge = "{{edit_motion_symmetric}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3440,7 +3376,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -defaults = "edit.motion.symmetric" +merge = "{{edit_motion_symmetric}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3448,19 +3384,19 @@ key = "shift+o" command = "selection-utilities.activeAtStart" [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" name = "undo" key = "u" command = "undo" [[bind]] -defaults = "edit.action.symmetric" +merge = "{{edit_action_symmetric}}" name = "redo" key = "shift+u" command = "redo" [[bind]] -defaults = "edit.motion.symmetric" +merge = "{{edit_motion_symmetric}}" key = "v" name = "shrink selection" description = """ From 08af0f9e4d362b630a78547b4bedb8fa7b7225ef Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 31 Jul 2025 00:57:10 -0400 Subject: [PATCH 18/79] working error reporting in javascript Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 33 +++++---- notes.md | 18 +++-- src/extension/keybindings/index.ts | 54 +++++++++++++- src/presets/larkin.toml | 72 +++++++++---------- src/rust/parsing/Cargo.lock | 10 +++ src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/src/bind.rs | 4 +- src/rust/parsing/src/error.rs | 36 ++++++---- src/rust/parsing/src/file.rs | 7 +- .../test-workspace/my_bindings.mk.toml | 20 ++++++ 10 files changed, 181 insertions(+), 74 deletions(-) create mode 100644 src/test/integration/test-workspace/my_bindings.mk.toml diff --git a/.vscode/settings.json b/.vscode/settings.json index c2bacb02..f1930cf4 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,4 +1,11 @@ { + "editor.formatOnSave": true, + "eslint.validate": [ + "javascript", + "javascriptreact", + "yaml", + "github-actions-workflow" // for GitHub Actions workflow files + ], "rust-analyzer.linkedProjects": [ "src/rust/parsing/Cargo.toml" ], @@ -10,19 +17,19 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "titleBar.activeBackground": "#7279f9", - "titleBar.activeForeground": "#000000", - "titleBar.inactiveBackground": "#7279f9", - "titleBar.inactiveForeground": "#000000", - "titleBar.border": "#7279f9", - "activityBar.background": "#7279f9", - "activityBar.foreground": "#000000", - "statusBar.background": "#7279f9", - "statusBar.foreground": "#000000", - "statusBar.debuggingBackground": "#7279f9", - "statusBar.debuggingForeground": "#000000", - "tab.activeBorder": "#7279f9", + "titleBar.activeBackground": "#d57aff", + "titleBar.activeForeground": "#FFFFFF", + "titleBar.inactiveBackground": "#d57aff", + "titleBar.inactiveForeground": "#FFFFFF", + "titleBar.border": "#d57aff", + "activityBar.background": "#d57aff", + "activityBar.foreground": "#FFFFFF", + "statusBar.background": "#d57aff", + "statusBar.foreground": "#FFFFFF", + "statusBar.debuggingBackground": "#d57aff", + "statusBar.debuggingForeground": "#FFFFFF", + "tab.activeBorder": "#d57aff", "iLoveWorkSpaceColors": true, "iLoveWorkSpaceRandom": false - } + }, } diff --git a/notes.md b/notes.md index 4f88dba7..a0426e7f 100644 --- a/notes.md +++ b/notes.md @@ -68,9 +68,9 @@ Integration test debugging: 3. Refactor parsing to rust a. in this early phase, we don't worry too much about providing detailed error messages (if there are easy things to do here we can do them, but no UX work, etc...) - - [ ] start by implementing parsing of `[[bind]]` + - [x] start by implementing parsing of `[[bind]]` - [X] basic parsing - - [X] merging defaults (unit tests remain) + - [X] merging defaults - [X] refactor code - [X] initial coverage output - https://crates.io/crates/cargo-tarpaulin @@ -82,14 +82,20 @@ Integration test debugging: - [x] include `Spanned` in fields of `BindInput` - [ ] pipeline for `[[bind]]` entries - [X] basic pipeline + - [X] implement parsing of vscode file with rust command (and generate problems) + - [X] we need to detect that the file should be parsed + - [X] we need to send detected files to the rust parser + - [X] we need to process errors to generate the diagnostic outputs - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs + - [ ] expansion of `[define]` sections + - [ ] make sure to error on fields that cannot have runtime computation + (only certain fields can be evaluated at runtime: `args` and `repeat`) + - [ ] get basic interpolation of `{{var}}` elements working for `bind` and its fields - [ ] cleanup and refactor code - - NOTE: we're waiting until we test out spans, because that could require - more refactoring - - [ ] proper parsing with `[[default]]` and `defaults` + - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] foreach expansion - - [ ] command normalization (always `runCommand` with an array of objects with `command` field) + - [X] command normalization (always `runCommand` with an array of objects with `command` field) - [ ] check constraints - [ ] validation that `master-key.prefix` uses `finalKey: false` - [ ] validation that keybindings with non modifier keybindings diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 35bb69a6..05f59b5f 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -642,10 +642,61 @@ async function loadPresets(allDirs: vscode.Uri[]) { let extensionPresetsDir: vscode.Uri; +async function validateKeybindings(file: vscode.Uri) { + if (file.toString().endsWith('.mk.toml')) { + const fileData = await vscode.workspace.fs.readFile(file); + // TODO: read bytes directly in `parse_string` to avoid extra copies + const fileString = new TextDecoder('utf8').decode(fileData); + const parsed = parse_string(fileString); + if (parsed.error) { + const diagnosticItems: vscode.Diagnostic[] = []; + let message = ''; + for (const item of parsed.error.items) { + if (item.message) { + message += item.message + '\n'; + } + if (item.range) { + diagnosticItems.push( + new vscode.Diagnostic( + new vscode.Range( + new vscode.Position( + item.range.start.line, + item.range.start.col, + ), + new vscode.Position( + item.range.end.line, + item.range.end.col, + ), + ), + message, + vscode.DiagnosticSeverity.Error, + ), + ); + message = ''; + } + } + diagnostics.set(file, diagnosticItems); + } else { + diagnostics.delete(file); + } + } +} + +let diagnostics: vscode.DiagnosticCollection; + export async function activate(context: vscode.ExtensionContext) { updateConfig(undefined, false); vscode.workspace.onDidChangeConfiguration(updateConfig); + diagnostics = vscode.languages.createDiagnosticCollection('Master Key Bindings'); + + vscode.workspace.onDidSaveTextDocument(async (e) => { + await validateKeybindings(e.uri); + }); + vscode.workspace.onDidOpenTextDocument(async (e) => { + await validateKeybindings(e.uri); + }); + // initialize rust WASM module for parsing keybinding files const filename = vscode.Uri.joinPath(context.extensionUri, 'out', 'parsing_bg.wasm'); const bits = await vscode.workspace.fs.readFile(filename); @@ -699,9 +750,8 @@ export async function activate(context: vscode.ExtensionContext) { kind: ${binding.kind} `); } else if (parsed.error) { - const report = parsed.error.report(); let message = ''; - for (const item of report.items) { + for (const item of parsed.error.items) { message += (item.message || '') + ' at ' + (item.range ? `(${item.range.start}, ${item.range.end})` : '') + '\n'; diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index d2b7181c..8972863e 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -357,7 +357,7 @@ key = "shift+x" name = "exapand" description = "expand selections to full lines" command = "expandLineSelection" -computedRepeat = "{{count}}" +repeat = "{{count}}" [[define.edit_motion_obj]] command = "selection-utilities.moveBy" @@ -649,7 +649,7 @@ name = "repeat motion" description = """ Repeat the last motion command. Motions usually move the cursor or change the selection. """ -computedRepeat = "{{count}}" +repeat = "{{count}}" command = "master-key.replayFromHistory" args.whereComputedIndexIs = """ commandHistory[index].tags.contains('motion') && @@ -1576,7 +1576,7 @@ key = "c" when = "!editorHasSelection && master-key.count > 1" command = "runCommands" args.commands = [ - { defined = "selectLinesDown" }, + "{{selectLinesDown}}", "deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert", @@ -1605,7 +1605,7 @@ mode = ["normal", "selectedit"] when = "master-key.count > 1" command = "runCommands" args.commands = [ - { defined = "selectLinesUp" }, + "{{selectLinesUp}}", "deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert", @@ -1705,7 +1705,7 @@ See also `,` which repeats the last subject. """ key = "." command = "runCommands" -computedRepeat = "{{count}}" +repeat = "{{count}}" [[bind.args.commands]] command = "master-key.replayFromHistory" @@ -1751,7 +1751,7 @@ count, delete up to the next `count` lines and store to clipboard. when = "!editorHasSelection" command = "runCommands" args.commands = [ - { defined = "selectLinesDown" }, + "selectLinesDown", "editor.action.clipboardCutAction", { command = "master-key.setMode", args = { value = "normal" } }, ] @@ -1784,7 +1784,7 @@ key = "shift+d" mode = "normal" when = "master-key.count > 1" command = "runCommands" -args.commands = [{ defined = "selectLinesUp" }, "deleteRight"] +args.commands = ["{{selectLinesUp}}", "deleteRight"] [[bind]] merge = "{{edit_action}}" @@ -1800,7 +1800,7 @@ key = "y" when = "master-key.count > 1" command = "runCommands" args.commands = [ - { defined = "selectLinesDown" }, + "{{selectLinesDown}}", "editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive", ] @@ -1825,7 +1825,7 @@ key = "shift+y" when = "master-key.count > 1" command = "runCommands" args.commands = [ - { defined = "selectLinesUp" }, + "{{selectLinesUp}}", "editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive", ] @@ -1838,13 +1838,13 @@ description = "Indent lines" command = "editor.action.indentLines" [[bind]] +args.commands = ["{{selectLinesDown}}", "editor.action.indentLines"] merge = "{{edit_action}}" key = "shift+." name = "indent" description = "Indent lines" when = "master-key.count >= 1" command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, "editor.action.indentLines"] [[bind]] merge = "{{edit_action}}" @@ -1855,17 +1855,17 @@ description = "De-indent lines" command = "editor.action.outdentLines" [[bind]] +args.commands = [ + "{{selectLinesDown}}", + "editor.action.outdentLines", + "selection-utilities.shrinkToActive", +] merge = "{{edit_action}}" key = "shift+," name = "deindent" when = "master-key.count >= 1" description = "Deindent lines" command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.outdentLines", - "selection-utilities.shrinkToActive", -] [define.edit_action_history] merge = "{{edit_action}}" @@ -2104,7 +2104,7 @@ key = "space j" mode = ["normal", "selectedit"] when = "!editorHasSelection" command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, 'editor.action.joinLines'] +args.commands = ["{{selectLinesDown}}", 'editor.action.joinLines'] [[bind]] merge = "{{edit_action}}" @@ -2124,6 +2124,11 @@ when = "master-key.count < 1" command = "editor.action.formatSelection" [[bind]] +args.commands = [ + "{{selectLinesDown}}", + "editor.action.formatSelection", + "selection-utilities.shrinkToActive", +] merge = "{{edit_action}}" key = "space f" combinedName = "format / format document" @@ -2133,11 +2138,6 @@ name = "format" description = "Format sel" when = "master-key.count >= 1" command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.formatSelection", - "selection-utilities.shrinkToActive", -] [[bind]] merge = "{{edit_action}}" @@ -2196,6 +2196,7 @@ when = "master-key.count < 1" command = "editor.action.commentLine" [[bind]] +args.commands = ["{{selectLinesDown}}", "editor.action.commentLine"] merge = "{{edit_action}}" key = "space /" name = "comment lines" @@ -2205,7 +2206,6 @@ combinedKey = "(shift+)/" description = "select next comment" when = "master-key.count >= 1" command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, "editor.action.commentLine"] [[bind]] merge = "{{edit_action}}" @@ -2215,6 +2215,11 @@ combinedName = "(block) comment" command = "editor.action.blockComment" [[bind]] +args.commands = [ + "{{selectLinesDown}}", + "editor.action.blockComment", + "selection-utilities.shrinkToActive", +] merge = "{{edit_action}}" key = "space shift+/" name = "block comment lines" @@ -2222,11 +2227,6 @@ combinedName = "(block) comment" description = "select previous comment" when = "master-key.count >= 1" command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.blockComment", - "selection-utilities.shrinkToActive", -] [[bind]] merge = "{{edit_action}}" @@ -2949,7 +2949,7 @@ description = "add cursor at the next match to the primary cursor's text" combinedDescription = "add cursor at the next/previous match to the primary cursor's text" key = "l" combinedKey = "l/h" -computedRepeat = "{{count}}" +repeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] @@ -2959,7 +2959,7 @@ combinedName = "add →/←" description = "add cursor at the previous match to the primary cursor's text" key = "h" command = "selection-utilities.addPrev" -computedRepeat = '{{count}}' +repeat = '{{count}}' [[bind]] merge = "{{edit_select_edit}}" @@ -2970,7 +2970,7 @@ combinedDescription = "move primary cursor to the next/previous match of the pri key = "shift+l" combinedKey = "shift+l/h" command = "selection-utilities.skipNext" -computedRepeat = "{{count}}" +repeat = "{{count}}" [[bind]] merge = "{{edit_select_edit}}" @@ -2979,7 +2979,7 @@ combinedName = "skip →/←" description = "move primary cursor to the previous match of the primary cursor's text" key = "shift+h" command = "selection-utilities.skipPrev" -computedRepeat = '{{count}}' +repeat = '{{count}}' [[bind]] merge = "{{edit_select_edit}}" @@ -3010,7 +3010,7 @@ what cursor you delete, and where the cursor goes when you clear or save selecti key = "j" combinedKey = "j/l" command = "selection-utilities.movePrimaryRight" -computedRepeat = '{{count}}' +repeat = '{{count}}' [[bind]] merge = "{{edit_select_edit}}" @@ -3019,7 +3019,7 @@ combinedName = "→/← sel" description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" key = "k" command = "selection-utilities.movePrimaryLeft" -computedRepeat = '{{count}}' +repeat = '{{count}}' [[bind]] merge = "{{edit_select_edit}}" @@ -3032,7 +3032,7 @@ combinedDescription = "insert cursor on line above/below" key = "shift+k" combinedKey = "shift+k/j" command = "editor.action.insertCursorAbove" -computedRepeat = "{{count}}" +repeat = "{{count}}" [[bind]] merge = "{{edit_select_edit}}" @@ -3043,7 +3043,7 @@ insert cursor on line below """ key = "shift+j" command = "editor.action.insertCursorBelow" -computedRepeat = "{{count-1}}" +repeat = "{{count-1}}" [[bind]] merge = "{{edit_select_edit}}" @@ -3056,7 +3056,7 @@ mode if all selections are deleted. """ key = "d" command = "selection-utilities.deletePrimary" -computedRepeat = "{{count-1}}" +repeat = "{{count-1}}" [[bind]] merge = "{{edit_select_edit}}" diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index c976feb2..554ad05b 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -416,6 +416,7 @@ dependencies = [ "regex", "serde", "serde-wasm-bindgen", + "string-offsets", "test-log", "thiserror", "toml", @@ -628,6 +629,15 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" +[[package]] +name = "string-offsets" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a651d1095b5b70f1a88e10dbcf58625e30140112b0f9f55f334e0f84ec2e3176" +dependencies = [ + "wasm-bindgen", +] + [[package]] name = "strsim" version = "0.11.1" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 5d74e5a8..30c82560 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -11,6 +11,7 @@ log = { version = "0.4.27", features = ["release_max_level_error"] } regex = "1.11.1" serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" +string-offsets = { version = "0.2.0", features = ["wasm"] } test-log = "0.2.18" thiserror = "2.0.12" toml = "0.9.2" diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index e536d261..d7c60b07 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -387,10 +387,10 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec, } +fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { + let start = offsets.utf8_to_char_pos(range.start); + let end = offsets.utf8_to_char_pos(range.end); + CharRange { start, end } +} + #[wasm_bindgen] impl ErrorWithContext { - pub fn report(&self) -> ErrorReport { + pub fn report(&self, content: &str) -> ErrorReport { let mut items = Vec::with_capacity(self.contexts.len() + 1); - items.push(ErrorReportItem { - message: Some(self.error.to_string()), - range: None, + let offsets: StringOffsets = StringOffsets::new(content); + items.push(match &self.error { + Error::Parsing(toml) => ErrorReportItem { + message: Some(toml.message().into()), + range: toml.span().map(|r| range_to_pos(r, &offsets)), + }, + _ => ErrorReportItem { + message: Some(self.error.to_string()), + range: None, + }, }); for context in &self.contexts { let item = match context { @@ -49,10 +63,7 @@ impl ErrorWithContext { }, Context::Range(range) => ErrorReportItem { message: None, - range: Some(ByteRange { - start: range.start, - end: range.end, - }), + range: Some(range_to_pos(range.clone(), &offsets)), }, }; items.push(item); @@ -61,6 +72,7 @@ impl ErrorWithContext { } } +#[derive(Debug, Clone)] #[wasm_bindgen(getter_with_clone)] pub struct ErrorReport { pub items: Vec, @@ -68,16 +80,16 @@ pub struct ErrorReport { #[wasm_bindgen] #[derive(Debug, Clone)] -pub struct ByteRange { - pub start: usize, - pub end: usize, +pub struct CharRange { + pub start: Pos, + pub end: Pos, } #[wasm_bindgen(getter_with_clone)] #[derive(Debug, Clone)] pub struct ErrorReportItem { pub message: Option, - pub range: Option, + pub range: Option, } #[derive(Debug, Clone)] diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 111c9d57..5eae999c 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,6 +1,7 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; -use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result}; +use crate::error::{Context, Error, ErrorContext, ErrorReport, ErrorWithContext, Result}; +use crate::file; use log::info; use serde::{Deserialize, Serialize}; @@ -38,7 +39,7 @@ impl KeyFile { #[wasm_bindgen(getter_with_clone)] pub struct KeyFileResult { pub file: Option, - pub error: Option, + pub error: Option, } #[wasm_bindgen] @@ -50,7 +51,7 @@ pub fn parse_string(file_content: &str) -> KeyFileResult { }, Err(err) => KeyFileResult { file: None, - error: Some(err), + error: Some(err.report(file_content)), }, }; } diff --git a/src/test/integration/test-workspace/my_bindings.mk.toml b/src/test/integration/test-workspace/my_bindings.mk.toml new file mode 100644 index 00000000..1fec2dbb --- /dev/null +++ b/src/test/integration/test-workspace/my_bindings.mk.toml @@ -0,0 +1,20 @@ +[[bind]] +command = "do" +args = { a = "2", b = 3 } +key = "a" +when = "joe > 1" +mode = "normal" +priority = 1 +defaults = "foo.bar" +prefixes = "c" +finalKey = true +repeat = "2+c" +name = "foo" +description = "foo bar bin" +hideInPalette = false +hideInDocs = false +combinedName = "foo/bar" +combinedKey = "A/B" +combinedDescription = "bla bla bla" +kind = "biz" +whenComputed = "f > 2" From 98b8849c7d6e103442ed7643e337a158084dfbae Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 31 Jul 2025 22:51:09 -0400 Subject: [PATCH 19/79] error reporting cleanup Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 33 +++------ notes.md | 2 +- src/extension/keybindings/index.ts | 67 +++++++++++-------- src/rust/parsing/src/bind.rs | 12 ++-- src/rust/parsing/src/error.rs | 2 +- src/rust/parsing/src/file.rs | 44 +++++++----- .../test-workspace/my_bindings.mk.toml | 25 ++++++- 7 files changed, 107 insertions(+), 78 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index f1930cf4..2450edfb 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,27 +9,14 @@ "rust-analyzer.linkedProjects": [ "src/rust/parsing/Cargo.toml" ], - "workbench.colorCustomizations": { - "editorBracketHighlight.foreground1": "#1b9e77", - "editorBracketHighlight.foreground2": "#d95f02", - "editorBracketHighlight.foreground3": "#7570b3", - "editorBracketHighlight.foreground4": "#e7298a", - "editorBracketHighlight.foreground5": "#66a61e", - "editorBracketHighlight.foreground6": "#e6ab02", - "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "titleBar.activeBackground": "#d57aff", - "titleBar.activeForeground": "#FFFFFF", - "titleBar.inactiveBackground": "#d57aff", - "titleBar.inactiveForeground": "#FFFFFF", - "titleBar.border": "#d57aff", - "activityBar.background": "#d57aff", - "activityBar.foreground": "#FFFFFF", - "statusBar.background": "#d57aff", - "statusBar.foreground": "#FFFFFF", - "statusBar.debuggingBackground": "#d57aff", - "statusBar.debuggingForeground": "#FFFFFF", - "tab.activeBorder": "#d57aff", - "iLoveWorkSpaceColors": true, - "iLoveWorkSpaceRandom": false - }, + "workbench.colorCustomizations": {}, + "window.title": "${activeEditorShort}${separator}${rootName}${separator}${profileName}", + "projectColors.name": "vscode-master-key", + "projectColors.mainColor": "#681dd7", + "projectColors.isActivityBarColored": false, + "projectColors.isTitleBarColored": false, + "projectColors.isStatusBarColored": false, + "projectColors.isProjectNameColored": false, + "projectColors.isActiveItemsColored": false, + "projectColors.setWindowTitle": false, } diff --git a/notes.md b/notes.md index a0426e7f..cb380a65 100644 --- a/notes.md +++ b/notes.md @@ -86,7 +86,7 @@ Integration test debugging: - [X] we need to detect that the file should be parsed - [X] we need to send detected files to the rust parser - [X] we need to process errors to generate the diagnostic outputs - - [ ] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region + - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] expansion of `[define]` sections - [ ] make sure to error on fields that cannot have runtime computation diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 05f59b5f..e080acf2 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -11,7 +11,7 @@ import { } from './parsing'; import { processBindings, Bindings } from './processing'; import { isSingleCommand } from '../utils'; -import { pick } from 'lodash'; +import { pick, debounce } from 'lodash'; import replaceAll from 'string.prototype.replaceall'; import { Utils } from 'vscode-uri'; import { @@ -642,37 +642,44 @@ async function loadPresets(allDirs: vscode.Uri[]) { let extensionPresetsDir: vscode.Uri; -async function validateKeybindings(file: vscode.Uri) { +async function validateKeybindings(file: vscode.Uri, fileString?: string) { if (file.toString().endsWith('.mk.toml')) { - const fileData = await vscode.workspace.fs.readFile(file); + if (fileString === undefined) { + const fileData = await vscode.workspace.fs.readFile(file); + fileString = new TextDecoder('utf8').decode(fileData); + } // TODO: read bytes directly in `parse_string` to avoid extra copies - const fileString = new TextDecoder('utf8').decode(fileData); const parsed = parse_string(fileString); - if (parsed.error) { + if (parsed.errors) { const diagnosticItems: vscode.Diagnostic[] = []; - let message = ''; - for (const item of parsed.error.items) { - if (item.message) { - message += item.message + '\n'; - } - if (item.range) { - diagnosticItems.push( - new vscode.Diagnostic( - new vscode.Range( - new vscode.Position( - item.range.start.line, - item.range.start.col, - ), - new vscode.Position( - item.range.end.line, - item.range.end.col, + for (const error of parsed.errors) { + let message = ''; + for (const item of error.items) { + if (item.message) { + message += item.message + '\n'; + } + if (item.range) { + diagnosticItems.push( + new vscode.Diagnostic( + new vscode.Range( + new vscode.Position( + item.range.start.line, + item.range.start.col, + ), + new vscode.Position( + item.range.end.line, + item.range.end.col, + ), ), + message, + vscode.DiagnosticSeverity.Error, ), - message, - vscode.DiagnosticSeverity.Error, - ), - ); - message = ''; + ); + message = ''; + } + } + if (message) { + diagnosticItems[diagnosticItems.length - 1].message += message; } } diagnostics.set(file, diagnosticItems); @@ -690,6 +697,10 @@ export async function activate(context: vscode.ExtensionContext) { diagnostics = vscode.languages.createDiagnosticCollection('Master Key Bindings'); + vscode.workspace.onDidChangeTextDocument(async (e) => { + debounce(() => validateKeybindings(e.document.uri, e.document.getText()), 500)(); + }); + vscode.workspace.onDidSaveTextDocument(async (e) => { await validateKeybindings(e.uri); }); @@ -749,9 +760,9 @@ export async function activate(context: vscode.ExtensionContext) { combinedDescription: ${binding.combinedDescription} kind: ${binding.kind} `); - } else if (parsed.error) { + } else if (parsed.errors) { let message = ''; - for (const item of parsed.error.items) { + for (const item of parsed.errors[0].items) { message += (item.message || '') + ' at ' + (item.range ? `(${item.range.start}, ${item.range.end})` : '') + '\n'; diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index d7c60b07..ea211f39 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -382,11 +382,11 @@ impl BindingInput { fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec)> { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); let command_pos = input.command.span(); - let command = input.command.get_ref().clone().resolve("command")?; + let command = input.command.get_ref().clone().resolve("`command` field")?; let args = input.args.clone(); if command == "runCommands" { let spanned = args - .require("`args`") + .require("`args` field") .context(Context::String( "`runCommands` must have `args` field".into(), )) @@ -395,7 +395,7 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Result<(BindingInput, Vec { let command_name = kv .get("command") - .require("`command`")? + .require("`command` field")? .as_str() .require("`command` to be string") .context(Context::Range(args_pos.clone()))? .to_owned(); let args = command .get("args") - .require("`args`")? + .require("`args` field")? .as_table() .require("`args` to be a table")? .to_owned(); @@ -462,7 +462,7 @@ impl Binding { return Ok(Binding { commands: commands, - key: input.key.into_inner().require("key")?, + key: input.key.into_inner().require("`key` field")?, when: input.when.into_inner().to_array(), mode: input.mode.into_inner().to_array(), priority: input.priority.map(|x| x.into_inner()).unwrap_or(0), diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 7aabac66..9982782b 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -16,7 +16,7 @@ pub enum Error { Validation(#[from] validator::ValidationError), #[error("expected {0}")] ConstraintError(&'static str), - #[error("required {0}")] + #[error("requires {0}")] RequiredField(&'static str), #[error("unexpected {0}")] Unexpected(&'static str), diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 5eae999c..9fb42dc0 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -22,24 +22,31 @@ pub struct KeyFile { } impl KeyFile { - fn new(input: KeyFileInput) -> Result { - return Ok(KeyFile { - bind: input - .bind - .into_iter() - .map(|b| { - let span = b.span(); - return Binding::new(b.into_inner()).context(Context::Range(span)); - }) - .collect::>>()?, - }); + fn new(input: KeyFileInput) -> std::result::Result> { + let mut errors = Vec::new(); + let result = input + .bind + .into_iter() + .filter_map(|b| { + let span = b.span(); + Binding::new(b.into_inner()) + .context(Context::Range(span)) + .map_err(|e| errors.push(e)) + .ok() + }) + .collect(); + if !errors.len() > 0 { + return Err(errors); + } else { + return Ok(KeyFile { bind: result }); + } } } #[wasm_bindgen(getter_with_clone)] pub struct KeyFileResult { pub file: Option, - pub error: Option, + pub errors: Option>, } #[wasm_bindgen] @@ -47,18 +54,21 @@ pub fn parse_string(file_content: &str) -> KeyFileResult { return match parse_string_helper(file_content) { Ok(result) => KeyFileResult { file: Some(result), - error: None, + errors: None, }, Err(err) => KeyFileResult { file: None, - error: Some(err.report(file_content)), + errors: Some(err.iter().map(|e| e.report(file_content)).collect()), }, }; } -fn parse_string_helper(file_content: &str) -> Result { - let result = toml::from_str::(file_content)?; - return KeyFile::new(result); +fn parse_string_helper(file_content: &str) -> std::result::Result> { + let parsed = toml::from_str::(file_content); + return match parsed { + Ok(input) => KeyFile::new(input), + Err(err) => return Err(vec![err.into()]), + }; } #[cfg(test)] diff --git a/src/test/integration/test-workspace/my_bindings.mk.toml b/src/test/integration/test-workspace/my_bindings.mk.toml index 1fec2dbb..3080950d 100644 --- a/src/test/integration/test-workspace/my_bindings.mk.toml +++ b/src/test/integration/test-workspace/my_bindings.mk.toml @@ -1,7 +1,28 @@ [[bind]] -command = "do" -args = { a = "2", b = 3 } key = "a" +command = "foo" +args = { a = "2", b = 3 } +when = "joe > 1" +mode = "normal" +priority = 1 +defaults = "foo.bar" +prefixes = "c" +finalKey = true +repeat = "2+c" +name = "foo" +description = "foo bar bin" +hideInPalette = false +hideInDocs = false +combinedName = "foo/bar" +combinedKey = "A/B" +combinedDescription = "bla bla bla" +kind = "biz" +whenComputed = "f > 2" + +[[bind]] +key = "b" +command = "bar" +args = { a = "2", b = 3 } when = "joe > 1" mode = "normal" priority = 1 From 711c27123aa2acad447efef22f8286f6e442680d Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 1 Aug 2025 00:02:38 -0400 Subject: [PATCH 20/79] larkin updates Created using spr 1.3.6-beta.1 --- src/presets/larkin.toml | 712 ++++++++++++++++++++-------------------- 1 file changed, 353 insertions(+), 359 deletions(-) diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 8972863e..7b8b6b63 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -56,9 +56,8 @@ name = "selectedit" highlight = "Highlight" cursorShape = "BlockOutline" -[define] +[define.var] select_on = false -around_on = false [[kind]] name = "motion" @@ -78,29 +77,24 @@ description = """ Assorted other commands that aren't motions or actions """ -[[define.selectLinesDown]] -command = "selection-utilities.shrinkToActive" - -[[define.selectLinesDown]] -abort = "{{count <= 0}}" -command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" } - -[[define.selectLinesDown]] -command = "expandLineSelection" +[define.command.selectLinesDown] +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "cursorMove", args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" }, abort = "{{count <= 0}}" }, + "expandLineSelection", + "selection-utilities.exchangeAnchorActive", +] -[[define.selectLinesUp]] +[define.command.selectLinesUp] command = "selection-utilities.shrinkToActive" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "cursorMove", args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" }, abort = "{{count <= 0}}" }, + "expandLineSelection", +] -[[define.selectLinesUp]] -abort = "{{count <= 0}}" -command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" } - -[[define.selectLinesUp]] -command = "expandLineSelection" - -[define.modes] +[define.bind.modes] kind = "util" # ## Getting Help @@ -112,7 +106,7 @@ kind = "util" # 3. The suggestion palette shows a list of the current bindings given the current key binding prefix. [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" key = "shift+;" name = "suggest" finalKey = false @@ -154,7 +148,7 @@ command = "master-key.showVisualDoc" # While in Normal model you will see a highlighted section with the text "normal" in the lower left hand corner of the status bar. [[bind]] -merge = "{{modes}}" +merge = "{{bind.modes}}" name = "normal" description = "Enter normal mode" foreach.key = ["escape", "ctrl+["] @@ -170,7 +164,7 @@ when = "!findWidgetVisible" prefixes = "{{all_prefixes}}" [[bind]] -merge = "{{modes}}" +merge = "{{bind.modes}}" name = "normal" foreach.key = ["escape", "ctrl+["] key = "{{key}}" @@ -184,7 +178,7 @@ prefixes = "{{all_prefixes}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect [[bind]] -merge = "{{modes}}" +merge = "{{bind.modes}}" name = "ignore" description = "this key does nothing" foreach.key = [ @@ -200,12 +194,12 @@ hideInDocs = true hideInPalette = true priority = -10 -[define.edit] +[define.bind.edit] when = "editorTextFocus && !findWidgetVisible" mode = "normal" -[define.edit_count] -merge = "{{edit}}" +[define.bind.edit_count] +merge = "{{bind.edit}}" kind = "count" # ## Basic motions @@ -214,19 +208,19 @@ kind = "count" # Selection behavior uses the following logic: motions that move more than one character generally select the text "under" the motion. If a selection already exists (e.g. from a previous motion) additional motions extend that selection. You can always reset the selection using `v`, and several commands (e.g. `x`) operate on the next character rather than the current selection. -[define.edit_motion] -merge = "{{edit}}" +[define.bind.edit_motion] +merge = "{{bind.edit}}" kind = "motion" tags = ["motion"] -[define.edit_motion_prim] -merge = "{{edit_motion}}" +[define.bind.edit_motion_prim] +merge = "{{bind.edit_motion}}" command = "cursorMove" value = "{{count}}" -select = "{{editorHasSelection || select_on}}" +select = "{{editorHasSelection || var.select_on}}" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "h" name = "←" combinedName = "←/→" @@ -237,7 +231,7 @@ args.to = "left" mode = "normal" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "l" combinedName = "←/→" name = "→" @@ -245,7 +239,7 @@ description = "move right" args.to = "right" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "j" name = "↓" combinedName = "↓/↑" @@ -256,7 +250,7 @@ args.to = "down" args.by = "wrappedLine" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "k" name = "↑" description = "move up" @@ -265,7 +259,7 @@ args.to = "up" args.by = "wrappedLine" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "shift+h" name = "start" description = "start of line (alternates between first non-white and first)" @@ -275,7 +269,7 @@ combinedDescription = "move to start/end of line" command = "cursorHomeSelect" [[bind]] # we don't use prim because we don't want the defaults -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "shift+l" name = "end" combinedName = "start/end" @@ -285,7 +279,7 @@ args.to = "wrappedLineEnd" args.select = true [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "shift+k" name = "sel ↑" combinedName = "sel ↑/↓" @@ -308,7 +302,7 @@ command = "expandLineSelection" command = "selection-utilities.exchangeAnchorActive" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "shift+j" name = "sel ↓" combinedName = "sel ↑/↓" @@ -326,7 +320,7 @@ args = { to = "down", by = "wrappedLine", select = true, value = "count" } command = "expandLineSelection" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "ctrl+d" mode = ["normal", "insert"] name = "pg ↓" @@ -340,7 +334,7 @@ args.count = "{{(count || 1)/3}}" args.select = "{{mode == 'normal'}}" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "ctrl+u" mode = ["normal", "insert"] name = "pg ↑" @@ -352,20 +346,20 @@ args.count = "{{(count || 1)/3}}" args.select = "{{mode == 'normal'}}" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "shift+x" name = "exapand" description = "expand selections to full lines" command = "expandLineSelection" repeat = "{{count}}" -[[define.edit_motion_obj]] +[define.bind.edit_motion_obj] command = "selection-utilities.moveBy" args.boundary = "start" args.select = true [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "w" name = "subwrd →" description = "next subword (camel/snake case)" @@ -376,7 +370,7 @@ args.unit = "subword" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "b" name = "subwrd ←" description = "previous subword (camel/snake case)" @@ -385,7 +379,7 @@ args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+w" name = "word →" description = "next word" @@ -396,7 +390,7 @@ args.unit = "word" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+b" name = "word ←" combinedName = "word ←/→" @@ -405,7 +399,7 @@ args.unit = "word" args.value = "{{-count || -1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "e" name = "subwrd end" description = "next subword (camel/snake case) end" @@ -414,7 +408,7 @@ args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+e" name = "word end" description = "next word end" @@ -423,7 +417,7 @@ args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+]" name = "parag. →" description = "next paragraph" @@ -434,7 +428,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+[" name = "parag. ←" combinedName = "paragraph →/←" @@ -443,7 +437,7 @@ args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+0" name = "subsec →" description = "next subsection" @@ -454,7 +448,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+9" name = "subsec ←" description = "previous subsection" @@ -463,7 +457,7 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "v" name = "shrink selection" combinedName = "shrink/hold selection" @@ -476,11 +470,11 @@ reduce all selections to length zero command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "select_on", value = false } }, + { command = "master-key.setFlag", args = { name = "var.select_on", value = false } }, ] [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "shift+v" name = "hold selection" combinedName = "shrink/hold selection" @@ -488,11 +482,11 @@ description = """ all motions extend the selection """ command = "master-key.setFlag" -args.name = "select_on" +args.name = "var.select_on" args.value = true [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "open, act →" description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" key = "o" @@ -507,14 +501,14 @@ command = "runCommands" args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "o" combinedName = "open below/above, act →/←" when = "editorHasSelection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -524,7 +518,7 @@ command = "runCommands" args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -533,14 +527,14 @@ when = "editorHasSelection" command = "selection-utilities.activeAtStart" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "shift+5" name = "to bracket" description = "Move to matching bracket" command = "editor.action.jumpToBracket" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = '\' name = "→ sel" combinedName = "→/← sel" @@ -558,7 +552,7 @@ command = "cursorMove" args = { to = "right", select = true, value = "{{count}}" } [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = 'shift+\' name = "← sel" combinedName = "→/← sel" @@ -574,21 +568,21 @@ command = "cursorMove" args = { to = "left", select = true, value = "{{count}}" } [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "shift+4" name = "all" description = "Select entire document" command = "editor.action.selectAll" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "shift+r" name = "trim wht" description = "trim external whitespace" command = "selection-utilities.trimSelectionWhitespace" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" name = "→ num." description = "Move to next number" key = "shift+3" @@ -601,7 +595,7 @@ args.boundary = "both" args.value = "{{(count || 1)}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" name = "← num." description = "Move to next number" key = "shift+2" @@ -612,7 +606,7 @@ args.boundary = "both" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = 'narrow to subword' description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" key = "z" @@ -643,7 +637,7 @@ hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = ";" name = "repeat motion" description = """ @@ -658,7 +652,7 @@ commandHistory[index].name != 'shrink selection' """ [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "repeat subject" description = """ Repeat the subject: a motion command that occurred right before an action. For @@ -675,7 +669,7 @@ commandHistory[index+1].tags.contains("history")) """ [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "cursor undo" key = "-" combinedName = "cursor undo/redo" @@ -683,14 +677,14 @@ combinedKey = "-/shift+-" command = "cursorUndo" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "cursor redo" combinedName = "cursor undo/redo" key = "shift+-" command = "cursorRedo" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "nav ←" description = "Go back in navigation history (e.g. goto definition)" combinedName = "nav ←/→" @@ -700,7 +694,7 @@ key = "g n" command = "workbench.action.navigateBackInNavigationLocations" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "nav →" combinedName = "nav ←/→" description = "Go forward in navigation history (e.g. goto definition)" @@ -708,7 +702,7 @@ key = "g shift+n" command = "workbench.action.navigateForwardInNavigationLocations" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "edit hist ←" description = "Go back in edit history" key = "g -" @@ -718,7 +712,7 @@ combinedDescription = "Go back/forward in edit history" command = "workbench.action.navigateBackInEditLocations" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "edit hist →" description = "Go forward in edit history)" key = "g shift+-" @@ -731,8 +725,8 @@ command = "workbench.action.navigateForwardInEditLocations" # # > I want some food -[define.edit_motion_search] -merge = "{{edit_motion}}" +[define.bind.edit_motion_search] +merge = "{{bind.edit_motion}}" command = "master-key.search" args.caseSensitive = false args.backwards = false @@ -740,7 +734,7 @@ args.selectTillMatch = true args.wrapAround = true [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "/" name = "search →" description = "search forwards" @@ -751,7 +745,7 @@ args.offset = "start" args.register = "search" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+/" name = "search ←" description = "search backwards" @@ -761,7 +755,7 @@ args.register = "search" args.backwards = true [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "n" name = "→ search" description = "Go to the next match of the search query" @@ -770,7 +764,7 @@ args.register = "search" args.repeat = "{{(count || 1)-1}}" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+n" name = "← search" description = "Go to the previous match of the search query" @@ -779,7 +773,7 @@ args.register = "search" args.repeat = "{{(count || 1)-1}}" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+8" name = "match →" description = "Next match to object under cursor" @@ -791,7 +785,7 @@ args.offset = "start" args.register = "search" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+7" name = "match ←" description = "Previous match to object under cursor" @@ -802,7 +796,7 @@ args.register = "search" args.backwards = true [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "f" name = "find char" description = "Find the next char (include char in selection)" @@ -814,7 +808,7 @@ args.skip = "{{count-1}}" args.offset = "inclusive" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+f" name = "find char back" description = "Find the previous char (include char in selection)" @@ -825,7 +819,7 @@ args.backwards = true args.skip = "{{count-1}}" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "t" name = "to char" description = "Find the next char (exclude char in selection)" @@ -837,7 +831,7 @@ args.offset = "start" args.skip = "{{count-1}}" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+t" name = "to char back" description = "Find the previous char (exclude char in selection)" @@ -848,7 +842,7 @@ args.backwards = true args.skip = "{{count-1}}" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "s" name = "find char pair" description = "To next character pair" @@ -861,7 +855,7 @@ args.skip = "{{count-1}}" mode = "normal" [[bind]] -merge = "{{edit_motion_search}}" +merge = "{{bind.edit_motion_search}}" key = "shift+s" name = "char pair back" description = "To previous character pair" @@ -877,7 +871,7 @@ args.backwards = true # motion commands that compliment the basic motions listed in the previous section. [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "g" priority = 1 name = "goto" @@ -888,7 +882,7 @@ or backwards in some direction. """ [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g j" priority = 1 name = "unwrp ↓" @@ -906,7 +900,7 @@ args.to = "down" args.by = "line" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g k" priority = 1 name = "unwrp ↑" @@ -916,7 +910,7 @@ args.to = "up" args.by = "line" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g shift+k" priority = 1 combinedName = "unwrp sel ↑/↓" @@ -938,7 +932,7 @@ args = { to = "up", by = "line", select = true, value = "{{count}}" } command = "expandLineSelection" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g shift+j" priority = 1 name = "sel ↓" @@ -958,7 +952,7 @@ args = { to = "down", by = "line", select = true, value = "{{count}}" } command = "expandLineSelection" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "shift+g" priority = 1 name = "doc end" @@ -969,7 +963,7 @@ combinedKey = ",/." command = "cursorBottomSelect" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -992,7 +986,7 @@ args.at = "center" args.lineNumber = "{{count}}" [[bind]] -merge = "{{edit_motion_prim}}" +merge = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -1001,7 +995,7 @@ command = "cursorTopSelect" when = "master-key.count <= 1" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "g w" priority = 1 name = "WORD →" @@ -1015,7 +1009,7 @@ args.unit = "BigWord" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "g b" priority = 1 name = "WORD ←" @@ -1025,17 +1019,17 @@ args.unit = "BigWord" args.value = "{{-count || -1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "g e" priority = 1 name = "WORD end →" description = "next WORD end; e.g. contiguous non-whitespace region" args.unit = "BigWord" -args.boundary = "{{around_on ? 'both' : 'end'}}" +args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "g 0" priority = 1 name = "sec →" @@ -1047,7 +1041,7 @@ args.unit = "section" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_obj}}" +merge = "{{bind.edit_motion_obj}}" key = "g 9" priority = 1 name = "sec ←" @@ -1057,7 +1051,7 @@ args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "goto line" priority = 1 description = "goto line command" @@ -1065,7 +1059,7 @@ key = "g l" command = "workbench.action.gotoLine" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "to refs" priority = 1 description = "jump to a location where this symbol is referenced" @@ -1073,7 +1067,7 @@ key = "g r" command = "editor.action.goToReferences" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "go to" priority = 1 description = "go to the definition of symbol under cursor" @@ -1084,7 +1078,7 @@ combinedDescription = "go to the definition of symbol (in an editor to the side) command = "editor.action.revealDefinition" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "go to, aside" priority = 1 description = "go to the definition of symbol under cursor in an editor to the side" @@ -1093,14 +1087,14 @@ combinedName = "go to (aside)" command = "editor.action.revealDefinitionAside" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "open" description = "open the file name under the cursor" key = "g f" command = "extension.openFileFromPath" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "g c" name = "cell →" combinedName = "cell →/←" @@ -1109,7 +1103,7 @@ args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] description = "previous jupyter notebook cell" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "g shift+c" name = "cell ←" combinedName = "cell →/←" @@ -1123,15 +1117,15 @@ args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] # If you accidentally select `around` instead of `in`, you can revise your selection using `R` to narrow to non-white space or `z` to narrow to a subword (e.g. excludes `_`) -[define.edit_motion_match_obj] -merge = "{{edit_motion}}" +[define.bind.edit_motion_match_obj] +merge = "{{bind.edit_motion}}" command = "selection-utilities.moveBy" kind = "motion" args.selectWhole = true args.boundary = "start" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m" name = "match" description = """ @@ -1141,14 +1135,14 @@ kind = "motion" command = "master-key.prefix" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m m" name = "smart expand" description = "Use VSCode's built-in smart expansion command" command = "editor.action.smartSelect.expand" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m w" name = "around subwrd →" description = "(camel/snake case)" @@ -1159,7 +1153,7 @@ args.unit = "subword" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m b" name = "around subwrd ←" description = "(camel/snake case)" @@ -1168,7 +1162,7 @@ args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+w" name = "ard word →" combinedName = "around word →/←" @@ -1177,7 +1171,7 @@ args.unit = "word" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+b" name = "ard word ←" combinedName = "around word →/←" @@ -1185,7 +1179,7 @@ args.unit = "word" args.value = "{{-count || -1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m e" name = "in subwrd" combinedName = "in → subword/word" @@ -1195,7 +1189,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+e" name = "in word" combinedName = "in → subword/word" @@ -1204,7 +1198,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m p" name = "in parag. →" combinedName = "in paragraph →/←" @@ -1214,7 +1208,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m o" name = "in parag. ←" combinedName = "in paragraph →/←" @@ -1223,7 +1217,7 @@ args.boundary = "both" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+p" name = "arn parag. →" combinedName = "around paragraph →/←" @@ -1232,7 +1226,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+o" name = "arn parag. ←" combinedName = "around paragraph →/←" @@ -1240,7 +1234,7 @@ args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m 0" name = "arn subsec →" combinedName = "around subsection →/←" @@ -1249,7 +1243,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+0" name = "arn subsec ←" combinedName = "around subsection →/←" @@ -1257,7 +1251,7 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m 9" name = "in subsec →" combinedName = "in subsection →/←" @@ -1266,7 +1260,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m shift+9" name = "in subsec ←" combinedName = "in subsection →/←" @@ -1274,14 +1268,14 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m g" name = "other..." description = "additional objects to match..." command = "master-key.prefix" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m g 0" name = "section →" combinedName = "section →/←" @@ -1290,7 +1284,7 @@ args.unit = "section" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m g 9" name = "section ←" combinedName = "section →/←" @@ -1298,7 +1292,7 @@ args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m g w" name = "around WORD →" combinedName = "around WORD →/←" @@ -1307,7 +1301,7 @@ args.unit = "BigWord" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m g b" name = "around WORD ←" combinedName = "around WORD →/←" @@ -1315,7 +1309,7 @@ args.unit = "BigWord" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{edit_motion_match_obj}}" +merge = "{{bind.edit_motion_match_obj}}" key = "m g e" name = "in WORD" args.unit = "BigWord" @@ -1323,7 +1317,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m [" name = "in parens" combinedName = "in/arnd parens" @@ -1339,7 +1333,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandWithinBrackets" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m shift+[" name = "arnd parens" combinedName = "in/arnd parens" @@ -1350,7 +1344,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandAroundBrackets" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m '" name = "in quotes" description = """ @@ -1366,7 +1360,7 @@ will seek out larger and larger scopes command = "bracketeer.selectQuotesContent" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m shift+'" name = "around quotes" combinedName = "in/arnd quotes" @@ -1378,7 +1372,7 @@ command = "runCommands" args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesContent"] [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m shift+." name = "in <>" description = "text inside angle brackets" @@ -1388,7 +1382,7 @@ combinedDescription = "text inside angle brackets / pairs (e.g. text in text< command = "extension.selectAngleBrackets" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m shift+," name = "in ><" combinedName = "in <> / in ><" @@ -1396,7 +1390,7 @@ description = "text inside tag pairs (e.g. text)" command = "extension.selectInTag" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m i" name = "in indent" description = "all text at the same indentation level" @@ -1409,7 +1403,7 @@ below this (ala c-like syntax) command = "vscode-select-by-indent.select-inner" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m shift+i" name = "arnd indent" description = """ @@ -1420,7 +1414,7 @@ combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" key = "m g i" name = "indent+top" description = """ @@ -1430,14 +1424,14 @@ combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer-top-only" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "in cell" description = "select text within a cell (ala jupyter)" key = "m c" command = "jupyter.selectCell" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "between pair" combinedDescription = """ Select between pairs of the same N characters (t) or distinct sets of N @@ -1464,7 +1458,7 @@ args.str = "{{captured}}" args.inclusive = false [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "between two" description = """ Select between two different sets of N characters, where N is the count e.g. @@ -1489,13 +1483,13 @@ args.inclusive = false # These are the most common, basic actions available in Larkin that can be used # to edit text in relation to the current selection. -[define.edit_action] +[define.bind.edit_action] kind = "action" mode = "normal" tags = ["action"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" #- TODO: add documentation to these basic editor keys key = "i" name = "insert" @@ -1505,7 +1499,7 @@ args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] mode = ["normal", "selectedit", "syminsert"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "a" name = "append" description = "insert after cursor" @@ -1518,7 +1512,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+i" name = "insert start" mode = ["normal", "selectedit", "syminsert"] @@ -1529,7 +1523,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+a" name = "insert end" mode = ["normal", "selectedit", "syminsert"] @@ -1540,7 +1534,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "c" name = "change" description = """ @@ -1552,14 +1546,14 @@ command = "runCommands" args.commands = ["deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "c" when = "!editorHasMultilineSelection && editorHasSelection" command = "runCommands" args.commands = ["deleteRight", "master-key.enterInsert"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "c" when = "!editorHasSelection && master-key.count <= 1" command = "runCommands" @@ -1571,7 +1565,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "c" when = "!editorHasSelection && master-key.count > 1" command = "runCommands" @@ -1583,7 +1577,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+c" name = "change to/back" description = """Without a count: change from current char to end of line. With a count: @@ -1599,7 +1593,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+c" mode = ["normal", "selectedit"] when = "master-key.count > 1" @@ -1612,7 +1606,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" args.commands = [ "selection-utilities.shrinkToActive", { command = "cursorMove", args = { to = "right", select = true, value = "{{count}}" } }, @@ -1624,14 +1618,14 @@ name = "delete char" command = "runCommands" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "r" name = "replace char" description = "replace the character under the cursor" command = "master-key.replaceChar" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "ctrl+i" name = "insert char" mode = ["normal", "selectedit"] @@ -1639,7 +1633,7 @@ description = "insert a character in front of the cursor" command = "master-key.insertChar" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "p" name = "paste after" description = "Paste clipboard after the cursor/selection" @@ -1655,7 +1649,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "p" name = "paste after" combinedName = "paste before/after/in" @@ -1664,7 +1658,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" mode = ["normal", "insert"] @@ -1674,7 +1668,7 @@ description = "Paste clipboard at location" command = "editor.action.clipboardPasteAction" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+p" name = "paste before" combinedName = "paste before/after" @@ -1688,7 +1682,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+p" combinedName = "paste before/after" when = "!editorHasSelection" @@ -1696,7 +1690,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "repeat action" description = """ Repeat the last action command. Actions usually modify the text of a document in one way or @@ -1720,28 +1714,28 @@ commandHistory[i].name == 'replay') command = "master-key.enterNormal" [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "undo" key = "u" command = "runCommands" args.commands = ["undo", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "redo" key = "shift+u" command = "runCommands" args.commands = ["redo", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'toggle check' description = "Toggle a markdown checkbox" key = "shift+6" command = "markdown-checkbox.markCheckbox" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "d" name = "delete" description = """ @@ -1751,13 +1745,13 @@ count, delete up to the next `count` lines and store to clipboard. when = "!editorHasSelection" command = "runCommands" args.commands = [ - "selectLinesDown", + "{{selectLinesDown}}", "editor.action.clipboardCutAction", { command = "master-key.setMode", args = { value = "normal" } }, ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "d" when = "editorHasSelection" command = "runCommands" @@ -1767,7 +1761,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+d" mode = "normal" name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." @@ -1779,7 +1773,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+d" mode = "normal" when = "master-key.count > 1" @@ -1787,7 +1781,7 @@ command = "runCommands" args.commands = ["{{selectLinesUp}}", "deleteRight"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "y" name = "copy" description = "copy selected text to clipboard" @@ -1795,7 +1789,7 @@ command = "runCommands" args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "y" when = "master-key.count > 1" command = "runCommands" @@ -1806,7 +1800,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+y" name = "copy (eol/up)" description = "without a count: copy to end of line; with a count: copy this and the previous N lines" @@ -1820,7 +1814,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+y" when = "master-key.count > 1" command = "runCommands" @@ -1831,7 +1825,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+." name = "indent" description = "Indent lines" @@ -1839,7 +1833,7 @@ command = "editor.action.indentLines" [[bind]] args.commands = ["{{selectLinesDown}}", "editor.action.indentLines"] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+." name = "indent" description = "Indent lines" @@ -1847,7 +1841,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+," name = "deindent" when = "master-key.count < 1" @@ -1860,15 +1854,15 @@ args.commands = [ "editor.action.outdentLines", "selection-utilities.shrinkToActive", ] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "shift+," name = "deindent" when = "master-key.count >= 1" description = "Deindent lines" command = "runCommands" -[define.edit_action_history] -merge = "{{edit_action}}" +[define.bind.edit_action_history] +merge = "{{bind.edit_action}}" tags = ["history"] # ## Number actions @@ -1876,14 +1870,14 @@ tags = ["history"] # These commands modify or enter numbers in some way. [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'inc #' description = "Increment a number by 1" key = "=" command = "selection-utilities.incrementNumber" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'dec #' description = "Decrement a number by 1 " key = "shift+=" @@ -1893,103 +1887,103 @@ command = "selection-utilities.decrementNumber" # These modify the capitalization of letters in some way. -[define.edit_action_capitals] -merge = "{{edit_action}}" +[define.bind.edit_action_capitals] +merge = "{{bind.edit_action}}" mode = ["normal", "selectedit"] [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'camel' description = "Swap style to lower camel case (`camelCase`)" key = "` c" command = "extension.changeCase.camel" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'constant' description = "Swap style to constant (`IS_CONSTANT`)" key = "` shift+u" command = "extension.changeCase.constant" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'dot' description = "Swap style to dot case (`dot.case`)" key = "` ." command = "extension.changeCase.dot" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'kebab' description = "Swap style to kebab case (`kebab-case`)" key = "` -" command = "extension.changeCase.kebab" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'all lower' description = "Swap all to lower case" key = "` shift+l" command = "extension.changeCase.lower" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'first lower' description = "Swap first letter to lower case" key = "` l" command = "extension.changeCase.lowerFirst" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'spaces' description = "Swap to spaces (`camelCase` -> `camel case`)" key = "` space" command = "extension.changeCase.no" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'Camel' description = "Swap to upper camel case (`CamelCase`)" key = "` shift+c" command = "extension.changeCase.pascal" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'path' description = "Swap to 'path' case (`path/case`)" key = "` /" command = "extension.changeCase.path" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'snake' description = "Swap to snake case (`snake_case`)" key = "` shift+-" command = "extension.changeCase.snake" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'swap' description = "Swap upper and lower case letters" key = "` s" command = "extension.changeCase.swap" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'title' description = "Swap to title case (all words have first upper case letter)" key = "` t" command = "extension.changeCase.title" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'all upper' description = "Swap to use all upper case letters" key = "` shift+y" command = "extension.changeCase.upper" [[bind]] -merge = "{{edit_action_capitals}}" +merge = "{{bind.edit_action_capitals}}" name = 'first upper' description = "Swap first character to upper case" key = "` u" @@ -2000,14 +1994,14 @@ command = "extension.changeCase.upperFirst" # These keys are all organized under the `space` key and they "do" something. These are generally more elaborate editing operations in the current editor pane. [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "do" key = "space" description = "additional actions, mostly for modifying specific syntactic formats" command = "master-key.prefix" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "paste after line" combinedName = "paste after/before line" combinedKey = "p/shift+p" @@ -2023,7 +2017,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" priority = 2 name = "paste before line" combinedName = "paste after/before line" @@ -2038,7 +2032,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" priority = 2 name = "add line below" combinedName = "add line below/above" @@ -2049,7 +2043,7 @@ key = "space o" command = "editor.action.insertLineAfter" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = "add line above" priority = 2 combinedName = "add line below/above" @@ -2058,7 +2052,7 @@ key = "space shift+o" command = "editor.action.insertLineBefore" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'sym insert' description = "Insert a character pair around a character" priority = 1 @@ -2074,19 +2068,19 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -args.before = "{{braces[captured].before || captured}}" -args.after = "{{braces[captured].after || captured}}" +args.before = "{{var.braces[captured].before || captured}}" +args.after = "{{var.braces[captured].after || captured}}" args.followCursor = true [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'trim white' description = "Delete all external whitespace (left and right edges)" key = "space shift+-" command = "selection-utilities.trimWhitespace" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space w" name = "wrap p" combinedName = "wrap/join lines" @@ -2096,7 +2090,7 @@ combinedKey = "w/j" command = "rewrap.rewrapComment" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'join' combinedName = "wrap/join lines" description = "Remove newline between current and next line" @@ -2107,7 +2101,7 @@ command = "runCommands" args.commands = ["{{selectLinesDown}}", 'editor.action.joinLines'] [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" combinedName = "wrap/join lines" name = 'join' description = "Remove newline between current and next line" @@ -2116,7 +2110,7 @@ key = "space j" command = "editor.action.joinLines" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space f" name = "format" combinedName = "format / format document" @@ -2129,7 +2123,7 @@ args.commands = [ "editor.action.formatSelection", "selection-utilities.shrinkToActive", ] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space f" combinedName = "format / format document" combinedKey = "f/shift+f" @@ -2140,56 +2134,56 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space shift+f" name = "format doc" combinedName = "format / format document" command = "editor.action.formatDocument" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'parens' description = "actions related to various brackets (`[`, `(`, `{`)" key = "space [" command = "master-key.prefix" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'remove' description = "Removes surrounding pairs" key = "space [ d" command = "bracketeer.removeBrackets" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'parens/brackets' description = "Swap between `[`, `(` and `{`" key = "space [ s" command = "bracketeer.swapBrackets" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'quotes' description = "Actions related to quotes" key = "space '" command = "master-key.prefix" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'remove' description = "Removes quotes (', \" or `)" key = "space ' d" command = "bracketeer.removeQuotes" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'swap' description = "Swap quotes (', \" or `)" key = "space ' s" command = "bracketeer.swapQuotes" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space /" combinedName = "(block) comment" when = "master-key.count < 1" @@ -2197,7 +2191,7 @@ command = "editor.action.commentLine" [[bind]] args.commands = ["{{selectLinesDown}}", "editor.action.commentLine"] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space /" name = "comment lines" combinedName = "(block) comment" @@ -2208,7 +2202,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space shift+/" when = "master-key.count < 1" combinedName = "(block) comment" @@ -2220,7 +2214,7 @@ args.commands = [ "editor.action.blockComment", "selection-utilities.shrinkToActive", ] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space shift+/" name = "block comment lines" combinedName = "(block) comment" @@ -2229,7 +2223,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'inc all #' combinedName = "inc/dec all #" combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" @@ -2239,7 +2233,7 @@ key = "space =" command = "selection-utilities.incrementNumberPerSelection" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'dec all #' combinedName = "inc/dec all #" description = "Decrement selected numbers; decrement increases per selection" @@ -2247,14 +2241,14 @@ key = "space shift+=" command = "selection-utilities.decrementNumberPerSelection" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" name = 'nb cell' description = "Actions related to notebook cells" key = "space c" command = "master-key.prefix" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space c i" when = "editorLangId == 'quarto'" command = "quarto.insertCodeCell" @@ -2262,13 +2256,13 @@ name = "insert cell" description = "insert a new cell in a notebook" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space c s" when = "editorLangId != 'quarto'" command = "jupyter.selectCell" [[bind]] -merge = "{{edit_action}}" +merge = "{{bind.edit_action}}" key = "space ." name = 'sent. lines' description = "Split paragraph into one line per sentence" @@ -2306,7 +2300,7 @@ command = "selection-utilities.cancelSelection" # These commands interact with the history of previously typed commands to repeat some sequence of commands. They can record any edits, and any commands that are issued through master key bindings. Commands that are not part of this binding file (e.g. a standard call to Cmd/Ctrl+V to paste) will not be recorded. You can copy your non-master-key bindings over to master key (so that they will be recorded) by [customizing your bindings](#customized-bindings) and using `Import Default Bindings` and `Import User Bindings` to allow all of the default and user bindings stored in VSCOde's normal keybinding files to be recorded by master key. (You will have to remove your original user bindings from the VSCOde `keybinding.json` file manually) [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "record" description = "Start/stop recording Master Key commands" key = "shift+q" @@ -2315,7 +2309,7 @@ command = "master-key.record" args.on = true [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "record" description = """ Start/stop recording key presses defined by Master Key pushing it to the @@ -2335,7 +2329,7 @@ args.whereComputedRangeIs.from = 'commandHistory[index-1].name === "record"' args.whereComputedRangeIs.to = "index" [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "replay" description = """ Replay the Master Key command sequence at the top of the `history` stack. Specifying @@ -2346,7 +2340,7 @@ command = "master-key.replayFromStack" args.index = "{{count}}" [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "store macro" description = """ Stores the top of the `history` stack into a named register. Specifying a count stores the @@ -2359,7 +2353,7 @@ args.register = "macro" args.contents = "macro[macro.length-(count || 0)-1]" [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "replay stored" description = """ Replay a recorded Master Key command sequence from a named register, pushing @@ -2382,7 +2376,7 @@ command = "master-key.replayFromStack" args.index = 0 [[bind]] -merge = "{{edit_action_history}}" +merge = "{{bind.edit_action_history}}" name = "store last" description = """ Store the N most recently run commands as a macro, where N is the count (defaulting to 1). @@ -2397,7 +2391,7 @@ args.whereComputedRangeIs.to = "index" # These actions include miscellaneous utilities. [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" key = "shift+ctrl+;" name = "palette" finalKey = false @@ -2411,14 +2405,14 @@ show command suggestions within the context of the current mode and keybinding p command = "master-key.commandPalette" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "git..." description = "git commands" key = "tab g" command = "master-key.prefix" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "pull" combinedName = "push/pull" description = "pull changes from remote" @@ -2428,14 +2422,14 @@ key = "tab g p" command = "git.pull" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "push" description = "push changes to remote" key = "tab g shift+p" command = "git.push" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "checkout" combinedName = "commit/checkout" description = "commit changes" @@ -2445,7 +2439,7 @@ key = "tab g c" command = "git.commit" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "checkout" combinedName = "commit/checkout" description = "checkout changes" @@ -2453,21 +2447,21 @@ key = "tab g shift+c" command = "git.checkout" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g r" command = "git.revertSelectedRanges" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g s" command = "git.stageSelectedRanges" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "commands..." description = "show GitLens command palette for git" key = "tab g g" @@ -2477,25 +2471,25 @@ command = "gitlens.gitCommands" # These miscellaneous utility commands are all organized uner the prefix `tab`. -[define.util] +[define.bind.util] when = "editorTextFocus && !findWidgetVisible" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "utility" key = "tab" description = "utility related commands: file opening, window manipulation, debugging etc..." command = "master-key.prefix" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "open recent" description = "Open recent file" key = "tab r" command = "workbench.action.openRecent" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "hover" description = "show the hover view" combinedName = "(debug) hover" @@ -2505,7 +2499,7 @@ key = "tab h" command = "editor.action.showHover" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "debug hover" combinedName = "(debug) hover" description = "show the debug hover view" @@ -2513,7 +2507,7 @@ key = "tab shift+h" command = "editor.debug.action.showDebugHover" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "add mark" combinedName = "add mark / mark..." description = "toggle bookmark at given line" @@ -2525,7 +2519,7 @@ combinedKey = "shift+m / m" command = "vsc-labeled-bookmarks.toggleBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "mark" combinedName = "add mark / mark..." description = "bookmark related commands" @@ -2533,39 +2527,39 @@ key = "tab m" command = "master-key.prefix" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "mark ↓" description = "move to next bookmark" combinedName = "mark ↓/↑" combinedDescription = "move to next/previous bookmark" combinedKey = "j/k" key = "tab m j" -when = "!master-key.select_on && !editorHasSelection" +when = "!master-key.var.select_on && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" combinedName = "mark ↓/↑" key = "tab m j" -when = "master-key.select_on || editorHasSelection" +when = "master-key.var.select_on || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" key = "tab m k" -when = "!master-key.select_on && !editorHasSelection" +when = "!master-key.var.select_on && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" key = "tab m k" -when = "master-key.select_on || editorHasSelection" +when = "master-key.var.select_on || editorHasSelection" command = "runCommands" args.commands = [ "vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", @@ -2573,21 +2567,21 @@ args.commands = [ ] [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "remove mark" description = "remove bookmark (use quick selection)" key = "tab m d" command = "vsc-labeled-bookmarks.deleteBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "nav marks" description = "reveal quick selection to move to a bookmark" key = "tab m t" command = "vsc-labeled-bookmarks.navigateToBookmark" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "error →" combinedName = "error →/←" combinedDescription = "move to next/previous error" @@ -2599,7 +2593,7 @@ key = "tab e" command = "editor.action.marker.next" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "error ←" combinedName = "error →/←" description = """ @@ -2609,7 +2603,7 @@ key = "tab shift+e" command = "editor.action.marker.prev" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "diff →" combinedName = "diff →/←" combinedDescription = "move to and show next/previous diff" @@ -2621,7 +2615,7 @@ key = "tab c" command = "editor.action.dirtydiff.next" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "diff ←" combinedName = "diff →/←" description = """ @@ -2631,7 +2625,7 @@ key = "tab shift+c" command = "editor.action.dirtydiff.previous" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "change →" combinedName = "change →/←" combinedDescription = "move to next/previous file change" @@ -2643,7 +2637,7 @@ key = "tab d" command = "workbench.action.editor.nextChange" [[bind]] -merge = "{{edit_motion}}" +merge = "{{bind.edit_motion}}" name = "change ←" combinedName = "change →/←" description = """ @@ -2656,13 +2650,13 @@ command = "workbench.action.editor.previousChange" # These are commands that interact with VSCode's user-interface in some way, rather than editing or moving around in the editor pane. -[define.window] +[define.bind.window] kind = "util" mode = "normal" when = "editorTextFocus && !findWidgetVisible" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "cntr win" description = "center window at primary cursor position" key = "tab l" @@ -2670,21 +2664,21 @@ command = "selection-utilities.revealActive" args.at = "center" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "window" description = "window/editor pane manipulation-related commands" key = "tab w" command = "master-key.prefix" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "vert/horz" key = "tab w r" description = "Toggle between horizontal and vertical layouts" command = "workbench.action.toggleEditorGroupLayout" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "next window" combinedName = "next/previous window" description = "move to next window" @@ -2694,7 +2688,7 @@ combinedKey = "]/[" command = "workbench.action.focusNextGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "prev window" combinedName = "next/previous window" description = "move to previous window" @@ -2702,7 +2696,7 @@ key = "tab [" command = "workbench.action.focusPreviousGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "move →" combinedName = "move →/←" combinedDescription = "move editor to window left/right" @@ -2712,7 +2706,7 @@ key = "tab w l" command = "workbench.action.moveEditorToRightGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "←" combinedName = "move →/←" description = "move editor to window to left" @@ -2720,7 +2714,7 @@ key = "tab w h" command = "workbench.action.moveEditorToLeftGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "↓" combinedName = "move ↓/↑" combinedDescription = "move editor to window above/below" @@ -2730,7 +2724,7 @@ key = "tab w j" command = "workbench.action.moveEditorToBelowGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "↑" combinedName = "move ↓/↑" description = "move editor to window above" @@ -2738,14 +2732,14 @@ key = "tab w k" command = "workbench.action.moveEditorToAboveGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "split editor..." description = "split editor to in a given direction" key = "tab w s" command = "master-key.prefix" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "move →" combinedName = "split →/←" combinedDescription = "move editor to window left/right" @@ -2755,7 +2749,7 @@ key = "tab w s l" command = "workbench.action.splitEditorRight" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "←" combinedName = "split →/←" description = "split editor to window to left" @@ -2763,7 +2757,7 @@ key = "tab w s h" command = "workbench.action.splitEditorLeft" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "↓" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2773,7 +2767,7 @@ key = "tab w s j" command = "workbench.action.splitEditorDown" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "↑" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2783,28 +2777,28 @@ key = "tab w s k" command = "workbench.action.splitEditorUp" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "close pane" description = "close the given group of editors" key = "tab w x" command = "workbench.action.closeEditorsInGroup" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "max" description = "minimize size of all other windows" key = "tab w shift+m" command = "workbench.action.minimizeOtherEditors" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "equal" description = "equalize size of all windows" key = "tab w =" command = "workbench.action.evenEditorWidths" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "curs. win top" description = "center window so that primary cursor is at the top" key = "tab k" @@ -2815,7 +2809,7 @@ command = "selection-utilities.revealActive" args.at = "top" [[bind]] -merge = "{{window}}" +merge = "{{bind.window}}" name = "curs. win bot" combinedName = "center window top/bottom" description = "center window so that primary cursor is at the bottom" @@ -2828,7 +2822,7 @@ args.at = "bottom" # Commands for interacting with VSCode's debugger UI. [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "breakpt." combinedName = "breakpt / debug..." combinedKey = "shift+b/b" @@ -2838,7 +2832,7 @@ key = "tab shift+b" command = "editor.debug.action.toggleBreakpoint" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "debug..." combinedName = "breakpt / debug..." description = "assorted debugging actions" @@ -2846,7 +2840,7 @@ key = "tab b" command = "master-key.prefix" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "cond. break" description = "conditional breakpoint" key = "tab b shift+c" @@ -2854,35 +2848,35 @@ command = "editor.debug.action.conditionalBreakpoint" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "start" description = "start debugging" key = "tab b r" command = "workbench.action.debug.start" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "continue" description = "continue debugging" key = "tab b c" command = "workbench.action.debug.continue" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "next" description = "debug: step over next line" key = "tab b j" command = "workbench.action.debug.stepOver" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "into" description = "debug: step into next line" key = "tab b i" command = "workbench.action.debug.stepInto" [[bind]] -merge = "{{util}}" +merge = "{{bind.util}}" name = "out" description = "debug: step out" key = "tab b o" @@ -2897,12 +2891,12 @@ command = "workbench.action.debug.stepOut" # - save a single selection to a list of selections to use for later and # then move the cursor to the next selection you wish to add -[define.edit_select_edit] +[define.bind.edit_select_edit] mode = "selectedit" kind = "motion" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "select-edit" description = """ Enter a mode where you can edit and manipulate (possibly multiple) selections. @@ -2913,7 +2907,7 @@ args.value = "selectedit" mode = "normal" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" key = "shift+'" combinedName = "rm cursors" combinedKey = "shift/ctrl+'" @@ -2925,7 +2919,7 @@ args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal" mode = ["selectedit", "normal"] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" key = "ctrl+'" mode = ["insert", "selectedit", "normal"] name = "rm cursors" @@ -2935,14 +2929,14 @@ command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = 'normal' description = "return to normal mode" key = "'" command = "master-key.enterNormal" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "add →" combinedName = "add →/←" description = "add cursor at the next match to the primary cursor's text" @@ -2953,7 +2947,7 @@ repeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "add ←" combinedName = "add →/←" description = "add cursor at the previous match to the primary cursor's text" @@ -2962,7 +2956,7 @@ command = "selection-utilities.addPrev" repeat = '{{count}}' [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "skip →" combinedName = "skip →/←" description = "move primary cursor to the next match of the primary cursor's text" @@ -2973,7 +2967,7 @@ command = "selection-utilities.skipNext" repeat = "{{count}}" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "skip ←" combinedName = "skip →/←" description = "move primary cursor to the previous match of the primary cursor's text" @@ -2982,21 +2976,21 @@ command = "selection-utilities.skipPrev" repeat = '{{count}}' [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "align ←" description = "align selections left" key = "=" command = "selection-utilities.alignSelectionsLeft" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "align →" description = "align selections right" key = "shift+=" command = "selection-utilities.alignSelectionsRight" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "→ sel" combinedName = "→/← sel" description = """ @@ -3013,7 +3007,7 @@ command = "selection-utilities.movePrimaryRight" repeat = '{{count}}' [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "← sel" combinedName = "→/← sel" description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" @@ -3022,7 +3016,7 @@ command = "selection-utilities.movePrimaryLeft" repeat = '{{count}}' [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "insert ↑" combinedName = "insert ↑/↓" description = """ @@ -3035,7 +3029,7 @@ command = "editor.action.insertCursorAbove" repeat = "{{count}}" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "insert sel ↓" combinedName = "insert ↑/↓" description = """ @@ -3046,7 +3040,7 @@ command = "editor.action.insertCursorBelow" repeat = "{{count-1}}" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "del. primary" combinedName = "del. primary/others" description = "remove the primary selection" @@ -3059,14 +3053,14 @@ command = "selection-utilities.deletePrimary" repeat = "{{count-1}}" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = 'del. others' description = "delete all other cursors but the primary selection" key = "shift+d" command = "removeSecondaryCursors" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "save sel" description = """ save all selections to the default register. @@ -3081,7 +3075,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "load sel" description = """ load previously saved selections in the default register. @@ -3094,7 +3088,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "exchange sel" description = """ exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. @@ -3107,7 +3101,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "rem saved sel" description = """ remove the most recently saved selection from the list of saved selections @@ -3120,7 +3114,7 @@ args.commands = [ ] [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" key = "shift+enter" name = "split sel" description = """ @@ -3129,7 +3123,7 @@ split selection into multiple selections by new line charactesr command = "selection-utilities.splitByNewline" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "sel all" description = """ create a selection for every match of the current word (or selection) @@ -3138,7 +3132,7 @@ key = "shift+8" command = "editor.action.selectHighlights" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "character" description = "split by a given character" key = "s" @@ -3153,14 +3147,14 @@ command = "selection-utilities.splitBy" args.text = "{{captured}}" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "string" description = "split by a given string" key = "shift+s" command = "selection-utilities.splitBy" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "include" description = """ Include all selections that contain a given marker @@ -3169,7 +3163,7 @@ key = "f" command = "selection-utilities.includeBy" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "exclude" description = """ Exclude all selections that contain a given marker @@ -3178,49 +3172,49 @@ key = "shift+f" command = "selection-utilities.excludeBy" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "create" description = "create selections of given string scoped to the current selections" key = "/" command = "selection-utilities.createBy" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "regex" description = "operations by regex rather than string" key = "r" command = "master-key.prefix" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "split" description = "split by a given regular expression" key = "r shift+s" command = "selection-utilities.splitByRegex" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "create" description = "create selections of given regular expression scoped to the current selections" key = "r /" command = "selection-utilities.createByRegex" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "include" description = "Include all selections that contain a given regular expression" key = "r f" command = "selection-utilities.includeByRegex" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "exclude" description = "Exclude all selections that contain a given regular expression" key = "r shift+f" command = "selection-utilities.excludeByRegex" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3230,7 +3224,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{edit_select_edit}}" +merge = "{{bind.edit_select_edit}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3243,7 +3237,7 @@ command = "selection-utilities.activeAtStart" # As a general rule, the letter keys issue commands of various sorts, and the other keys can be used to enter text (since we rarley want to surround a selection with an `a` but might want to surround it with `*` or `/`. -[define.braces] +[define.var.braces] "{".before = "{" "{".after = "}" @@ -3272,20 +3266,20 @@ cursorShape = "BlockOutline" [[mode.onType]] command = "selection-utilities.insertAround" -args.before = "{{braces[captured].before || captured}}" -args.after = "{{braces[captured].after || captured}}" +args.before = "{{var.braces[captured].before || captured}}" +args.after = "{{var.braces[captured].after || captured}}" args.followCursor = true -[define.edit_action_symmetric] +[define.bind.edit_action_symmetric] kind = "action" mode = "syminsert" -[define.edit_motion_symmetric] +[define.bind.edit_motion_symmetric] kind = "motion" mode = "syminsert" [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" name = "sym insert mode" priority = 1 description = """ @@ -3299,7 +3293,7 @@ command = "master-key.setMode" args.value = "syminsert" [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" name = "Normal" description = "Return to normal model" key = "enter" @@ -3307,7 +3301,7 @@ command = "master-key.setMode" mode = "syminsert" [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" foreach.key = ["{{key: [a-z]}}", "shift+{{key: [a-z]}}"] name = "" description = "this key is ignored and has no associated command in syminsert mode" @@ -3319,7 +3313,7 @@ hideInPalette = true [[bind]] name = "esc. char" -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" key = "\\" description = "Insert escaped character" command = "runCommands" @@ -3330,12 +3324,12 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -args.before = "{{'\\\\' + (braces[captured].before || captured)}}" -args.after = "{{'\\\\' + (braces[captured].after || captured)}}" +args.before = "{{'\\\\' + (var.braces[captured].before || captured)}}" +args.after = "{{'\\\\' + (var.braces[captured].after || captured)}}" args.followCursor = true [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" name = "delete" key = "x" description = """ @@ -3348,7 +3342,7 @@ args.count = "{{count}}" args.followCursor = true [[bind]] -merge = "{{edit_motion_symmetric}}" +merge = "{{bind.edit_motion_symmetric}}" key = "l" name = "sel →" description = "shrink/grow selections in direction that's rightwards from cursor" @@ -3357,7 +3351,7 @@ args.dir = "forward" args.count = "{{count}}" [[bind]] -merge = "{{edit_motion_symmetric}}" +merge = "{{bind.edit_motion_symmetric}}" key = "h" name = "sel ←" description = "shrink/grow selections in direction that's leftwards from cursor" @@ -3366,7 +3360,7 @@ args.dir = "backward" args.count = "{{count}}" [[bind]] -merge = "{{edit_motion_symmetric}}" +merge = "{{bind.edit_motion_symmetric}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3376,7 +3370,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{edit_motion_symmetric}}" +merge = "{{bind.edit_motion_symmetric}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3384,19 +3378,19 @@ key = "shift+o" command = "selection-utilities.activeAtStart" [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" name = "undo" key = "u" command = "undo" [[bind]] -merge = "{{edit_action_symmetric}}" +merge = "{{bind.edit_action_symmetric}}" name = "redo" key = "shift+u" command = "redo" [[bind]] -merge = "{{edit_motion_symmetric}}" +merge = "{{bind.edit_motion_symmetric}}" key = "v" name = "shrink selection" description = """ @@ -3405,6 +3399,6 @@ reduce all selections to length zero and return to normal mode command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "select_on", value = false } }, + { command = "master-key.setFlag", args = { name = "var.select_on", value = false } }, "master-key.enterNormal", ] From 8fcd402092109a607415aabca4fc489bd7d5c1f2 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 1 Aug 2025 00:03:14 -0400 Subject: [PATCH 21/79] wip `define` field Created using spr 1.3.6-beta.1 --- notes.md | 9 ++++++--- src/extension/keybindings/index.ts | 2 ++ src/rust/parsing/src/bind.rs | 19 +++++++++++++++++ src/rust/parsing/src/bind/validation.rs | 4 ++++ src/rust/parsing/src/define.rs | 27 +++++++++++++++++++++++++ src/rust/parsing/src/lib.rs | 1 + 6 files changed, 59 insertions(+), 3 deletions(-) create mode 100644 src/rust/parsing/src/define.rs diff --git a/notes.md b/notes.md index cb380a65..ca6efeb8 100644 --- a/notes.md +++ b/notes.md @@ -89,13 +89,16 @@ Integration test debugging: - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] expansion of `[define]` sections + - [ ] unit tests for `define` parsing + - [ ] get basic interpolation of `{{var}}` elements working for `bind` and its fields - [ ] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - - [ ] get basic interpolation of `{{var}}` elements working for `bind` and its fields - - [ ] cleanup and refactor code + - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] foreach expansion - - [X] command normalization (always `runCommand` with an array of objects with `command` field) + - [~] command normalization + - [X] always `runCommand` with an array of objects with `command` field + - [ ] flatten all nested `runCommands` calls - [ ] check constraints - [ ] validation that `master-key.prefix` uses `finalKey: false` - [ ] validation that keybindings with non modifier keybindings diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index e080acf2..5875a093 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -646,6 +646,8 @@ async function validateKeybindings(file: vscode.Uri, fileString?: string) { if (file.toString().endsWith('.mk.toml')) { if (fileString === undefined) { const fileData = await vscode.workspace.fs.readFile(file); + // TODO: at some point we can probably circumvent the need to decode the file + // (since we can write the rust code to accept bytes instead of a string) fileString = new TextDecoder('utf8').decode(fileData); } // TODO: read bytes directly in `parse_string` to avoid extra copies diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index ea211f39..117b4da4 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -274,13 +274,32 @@ impl Merging for BindingInput { } } +#[derive(Deserialize, Clone, Debug)] +pub struct CommandInput { + command: Spanned>, + args: Option>, +} + #[wasm_bindgen(getter_with_clone)] #[derive(Clone)] pub struct Command { + // TODO: add additional fields here pub command: String, pub args: JsValue, } +impl Command { + fn new(input: CommandInput) -> Result { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let command = input.command.into_inner().resolve("`command` field")?; + let args = input + .args + .serialize(&to_json) + .expect("while serializing command arguments"); + return Ok(Command { command, args }); + } +} + #[derive(Clone)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 245a2502..c1e53535 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -51,6 +51,10 @@ pub fn valid_json_array_object( .try_for_each(|(_, v)| valid_json_value(v)); } +trait MapLike { + fn no_reserved_fields(kv: &Self) -> std::result::Result<(), ValidationError>; +} + lazy_static! { static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); static ref KEY_REGEXS: Vec = vec![ diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs new file mode 100644 index 00000000..c92a3b5c --- /dev/null +++ b/src/rust/parsing/src/define.rs @@ -0,0 +1,27 @@ +use std::collections::HashMap; + +use crate::bind::{Binding, BindingInput, Command, CommandInput}; +use crate::error::{Context, ErrorContext}; + +#[allow(unused_imports)] +use log::info; +use serde::{Deserialize, Serialize}; +use serde_wasm_bindgen; +use toml::{Spanned, Value}; +use validator::Validate; +use wasm_bindgen::prelude::*; + +#[derive(Deserialize, Clone, Debug, Validate)] +struct DefineInput { + pub bind: Option>>, + pub command: Option>>, + pub var: Option, +} + +struct Define { + pub bind: Option>, + pub command: Option>, + pub var: Option, +} + +// TODO: tests diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index eb895cda..01765484 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -4,5 +4,6 @@ mod util; // [[bind]] level parsing mod bind; +mod define; // file level parsing pub mod file; From 1a41ca860860d29cc1473bc2a9192aafc4e86d49 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 1 Aug 2025 17:18:38 -0400 Subject: [PATCH 22/79] constructor for `define` Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/bind.rs | 2 +- src/rust/parsing/src/define.rs | 47 +++++++++++++++++++++++++++++++--- 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 117b4da4..055b21bc 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -289,7 +289,7 @@ pub struct Command { } impl Command { - fn new(input: CommandInput) -> Result { + pub fn new(input: CommandInput) -> Result { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); let command = input.command.into_inner().resolve("`command` field")?; let args = input diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index c92a3b5c..ade8f5a0 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,7 +1,7 @@ use std::collections::HashMap; use crate::bind::{Binding, BindingInput, Command, CommandInput}; -use crate::error::{Context, ErrorContext}; +use crate::error::{Context, ErrorContext, ErrorWithContext, Result}; #[allow(unused_imports)] use log::info; @@ -12,16 +12,57 @@ use validator::Validate; use wasm_bindgen::prelude::*; #[derive(Deserialize, Clone, Debug, Validate)] -struct DefineInput { +pub struct DefineInput { pub bind: Option>>, pub command: Option>>, pub var: Option, } -struct Define { +pub struct Define { pub bind: Option>, pub command: Option>, pub var: Option, } +fn map_with_err( + x: HashMap>, + f: &mut F, +) -> std::result::Result, Vec> +where + F: FnMut(T) -> Result, +{ + let mut errors = Vec::new(); + let result = x + .into_iter() + .filter_map(|(k, v)| { + let span = v.span(); + let result = f(v.into_inner()).context(Context::Range(span)); + return result.map_err(|e| errors.push(e)).ok().map(|v| (k, v)); + }) + .collect(); + if errors.len() > 0 { + return Err(errors); + } else { + return Ok(result); + } +} + +impl Define { + pub fn new(input: DefineInput) -> std::result::Result> { + let bind = match input.bind { + Some(x) => Some(map_with_err(x, &mut |b| Binding::new(b))?), + None => None, + }; + let command = match input.command { + Some(x) => Some(map_with_err(x, &mut |c| Command::new(c))?), + None => None, + }; + return Ok(Define { + bind, + command, + var: input.var, + }); + } +} + // TODO: tests From a6c74a61ed0e55ebaec5f5e6ba740d5a25870d72 Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 3 Aug 2025 15:26:35 -0400 Subject: [PATCH 23/79] `define` wip Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/bind.rs | 85 +++++++++--------- src/rust/parsing/src/define.rs | 158 ++++++++++++++++++++++++++++++++- src/rust/parsing/src/error.rs | 8 +- src/rust/parsing/src/file.rs | 44 ++++++--- src/rust/parsing/src/util.rs | 27 ++++-- 5 files changed, 257 insertions(+), 65 deletions(-) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 055b21bc..a84f6a6f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -71,7 +71,7 @@ pub struct BindingInput { * (see [running multiple commands](#running-multiple-commands)). */ #[serde(default = "span_required_default")] - command: Spanned>, + pub command: Spanned>, /** * @forBindingField bind @@ -81,7 +81,7 @@ pub struct BindingInput { */ #[validate(custom(function = "JsonObjectShape::valid_json_object"))] #[serde(default)] - args: Option>, + pub args: Option>, /** * @forBindingField bind @@ -92,7 +92,7 @@ pub struct BindingInput { */ #[serde(default = "span_required_default")] #[validate(custom(function = "valid_key_binding"))] - key: Spanned>, + pub key: Spanned>, /** * @forBindingField bind * @@ -102,7 +102,7 @@ pub struct BindingInput { * [available contexts](#available-contexts) */ #[serde(default = "span_plural_default")] - when: Spanned>, + pub when: Spanned>, /** * @forBindingField bind * @@ -112,7 +112,7 @@ pub struct BindingInput { * a binding that is applied in all modes use "{{all_modes}}". */ #[serde(default = "default_mode")] - mode: Spanned>, + pub mode: Spanned>, /** * @forBindingField bind * @@ -120,7 +120,7 @@ pub struct BindingInput { * bindings take precedence. Defaults to 0. */ #[serde(default)] - priority: Option>, + pub priority: Option>, /** * @forBindingField bind * @@ -128,7 +128,7 @@ pub struct BindingInput { * [`default`](/bindings/default) for more details. */ #[serde(default)] - defaults: Option>, + pub defaults: Option>, /** * @forBindingField bind * @@ -137,7 +137,7 @@ pub struct BindingInput { */ #[serde(default)] #[validate(custom(function = "valid_json_array_object"))] - foreach: Option>, + pub foreach: Option>, /** * @forBindingField bind @@ -152,7 +152,7 @@ pub struct BindingInput { * in Larkin). */ #[serde(default = "span_plural_default")] - prefixes: Spanned>, + pub prefixes: Spanned>, /** * @forBindingField bind @@ -162,7 +162,7 @@ pub struct BindingInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - finalKey: Option>, + pub finalKey: Option>, /** * @forBindingField bind @@ -191,7 +191,7 @@ pub struct BindingInput { * keys. Favor unicode symbols such as → and ← over text. */ #[serde(default)] - name: Option>, + pub name: Option>, /** * @forBindingField bind @@ -202,7 +202,7 @@ pub struct BindingInput { * for the literate comments. */ #[serde(default)] - description: Option>, + pub description: Option>, /** * @forBindingField bind * @order 10 @@ -211,9 +211,9 @@ pub struct BindingInput { * and the documentation. These both default to false. */ #[serde(default)] - hideInPalette: Option>, + pub hideInPalette: Option>, #[serde(default)] - hideInDocs: Option>, + pub hideInDocs: Option>, /** * @forBindingField bind @@ -227,11 +227,11 @@ pub struct BindingInput { * `combinedDescription` are ignored. */ #[serde(default)] - combinedName: Option>, + pub combinedName: Option>, #[serde(default)] - combinedKey: Option>, + pub combinedKey: Option>, #[serde(default)] - combinedDescription: Option>, + pub combinedDescription: Option>, /** * @forBindingField bind @@ -242,7 +242,7 @@ pub struct BindingInput { * entry in the top-level `kind` array. */ #[serde(default)] - kind: Option>, + pub kind: Option>, } impl Merging for BindingInput { @@ -276,31 +276,39 @@ impl Merging for BindingInput { #[derive(Deserialize, Clone, Debug)] pub struct CommandInput { - command: Spanned>, - args: Option>, + pub command: Spanned>, + pub args: Option>, } #[wasm_bindgen(getter_with_clone)] -#[derive(Clone)] +#[derive(Clone, Debug, Serialize)] pub struct Command { - // TODO: add additional fields here pub command: String, - pub args: JsValue, + args: toml::Table, } +#[wasm_bindgen] impl Command { - pub fn new(input: CommandInput) -> Result { + #[wasm_bindgen(getter)] + pub fn args(&self) -> std::result::Result { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - let command = input.command.into_inner().resolve("`command` field")?; - let args = input - .args - .serialize(&to_json) - .expect("while serializing command arguments"); - return Ok(Command { command, args }); + return self.args.serialize(&to_json); } } -#[derive(Clone)] +impl Command { + pub fn new(input: CommandInput) -> Result { + return Ok(Command { + command: input.command.into_inner().resolve("`command` field")?, + args: match input.args { + Some(x) => x.into_inner(), + None => toml::Table::new(), + }, + }); + } +} + +#[derive(Clone, Debug, Serialize)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct Binding { @@ -399,7 +407,6 @@ impl BindingInput { } fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec)> { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); let command_pos = input.command.span(); let command = input.command.get_ref().clone().resolve("`command` field")?; let args = input.args.clone(); @@ -447,12 +454,7 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Result<(BindingInput, Vec x.into_inner(), + None => toml::Table::new(), + }, }], )); } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index ade8f5a0..4022ab3a 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,7 +1,8 @@ use std::collections::HashMap; use crate::bind::{Binding, BindingInput, Command, CommandInput}; -use crate::error::{Context, ErrorContext, ErrorWithContext, Result}; +use crate::error::{Context, ErrorContext, ErrorWithContext, Result, unexpected}; +use crate::util::Requiring; #[allow(unused_imports)] use log::info; @@ -18,10 +19,49 @@ pub struct DefineInput { pub var: Option, } +#[wasm_bindgen] +#[derive(Clone, Debug, Default)] pub struct Define { - pub bind: Option>, - pub command: Option>, - pub var: Option, + bind: Option>, + command: Option>, + var: Option, +} + +#[wasm_bindgen] +impl Define { + pub fn bind(&self, key: &str) -> Result { + let value = self + .bind + .as_ref() + .require(format!("`{key}` field"))? + .get(key) + .require(format!("`{key}` field"))?; + return Ok(value.clone()); + } + + pub fn command(&self, key: &str) -> Result { + let value = self + .command + .as_ref() + .require(format!("`{key}` field"))? + .get(key) + .require(format!("`{key}` field"))?; + return Ok(value.clone()); + } + + pub fn var(&self, key: &str) -> Result { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let value = self + .var + .as_ref() + .require(format!("`{key}` field"))? + .get(key) + .require(format!("`{key}` field"))?; + return match value.serialize(&to_json) { + Ok(result) => Ok(result), + Err(_) => unexpected("unexpected serialization error"), + }; + } } fn map_with_err( @@ -57,6 +97,7 @@ impl Define { Some(x) => Some(map_with_err(x, &mut |c| Command::new(c))?), None => None, }; + return Ok(Define { bind, command, @@ -65,4 +106,113 @@ impl Define { } } +mod tests { + use test_log::test; + + use super::*; + #[test] + fn complete_parsing() { + let data = r#" + var.y = "bill" + + [bind.foo] + key = "x" + command = "foo" + args = { k = 1, h = 2 } + + [command.foobar] + command = "runCommands" + args.commands = ["foo", "bar"] + + [var.x] + joe = "bob" + "#; + + let result = toml::from_str::(data).unwrap(); + assert_eq!( + result + .var + .as_ref() + .unwrap() + .get("y") + .unwrap() + .as_str() + .unwrap(), + "bill" + ); + + assert_eq!( + result + .var + .as_ref() + .unwrap() + .get("x") + .unwrap() + .as_table() + .unwrap() + .get("joe") + .unwrap() + .as_str() + .unwrap(), + "bob" + ); + + let ref foo = result.bind.as_ref().unwrap().get("foo").unwrap().as_ref(); + assert_eq!(foo.key.as_ref().as_ref().unwrap(), "x"); + assert_eq!(foo.command.as_ref().as_ref().unwrap(), "foo"); + assert_eq!( + foo.args + .as_ref() + .unwrap() + .as_ref() + .get("k") + .unwrap() + .as_integer() + .unwrap(), + 1 + ); + assert_eq!( + foo.args + .as_ref() + .unwrap() + .as_ref() + .get("h") + .unwrap() + .as_integer() + .unwrap(), + 2 + ); + + let foobar = result + .command + .as_ref() + .unwrap() + .get("foobar") + .unwrap() + .as_ref(); + assert_eq!(foobar.command.as_ref().as_ref().unwrap(), "runCommands"); + let commands = foobar + .args + .as_ref() + .unwrap() + .as_ref() + .get("commands") + .unwrap(); + let command_list = commands.as_array().unwrap(); + assert_eq!(command_list[0].as_str().unwrap(), "foo"); + assert_eq!(command_list[1].as_str().unwrap(), "bar"); + + let define = Define::new(result); + let foo_out = define + .as_ref() + .unwrap() + .bind + .as_ref() + .unwrap() + .get("foo") + .unwrap(); + assert_eq!(foo_out.commands[0].command, "foo"); + } +} + // TODO: tests diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 9982782b..0a9233b0 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -17,7 +17,7 @@ pub enum Error { #[error("expected {0}")] ConstraintError(&'static str), #[error("requires {0}")] - RequiredField(&'static str), + RequiredField(String), #[error("unexpected {0}")] Unexpected(&'static str), #[error("parsing regex failed with {0}")] @@ -40,6 +40,12 @@ fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { CharRange { start, end } } +impl From for Vec { + fn from(value: ErrorWithContext) -> Self { + return vec![value]; + } +} + #[wasm_bindgen] impl ErrorWithContext { pub fn report(&self, content: &str) -> ErrorReport { diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 9fb42dc0..0825449b 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,5 +1,6 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; +use crate::define::{Define, DefineInput}; use crate::error::{Context, Error, ErrorContext, ErrorReport, ErrorWithContext, Result}; use crate::file; @@ -11,34 +12,54 @@ use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript #[derive(Deserialize, Clone, Debug)] struct KeyFileInput { - bind: Vec>, + define: Option, + bind: Option>>, } #[derive(Clone)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct KeyFile { + pub define: Define, pub bind: Vec, } impl KeyFile { fn new(input: KeyFileInput) -> std::result::Result> { let mut errors = Vec::new(); - let result = input + let bind = input .bind - .into_iter() - .filter_map(|b| { - let span = b.span(); - Binding::new(b.into_inner()) - .context(Context::Range(span)) - .map_err(|e| errors.push(e)) + .map(|bind| { + return bind + .into_iter() + .filter_map(|b| { + let span = b.span(); + Binding::new(b.into_inner()) + .context(Context::Range(span)) + .map_err(|e| errors.push(e)) + .ok() + }) + .collect(); + }) + .unwrap_or_default(); + + let define = input + .define + .map(|define| { + Define::new(define) + .map_err(|es| { + for e in es.into_iter() { + errors.push(e); + } + }) .ok() }) - .collect(); + .flatten() + .unwrap_or_default(); if !errors.len() > 0 { return Err(errors); } else { - return Ok(KeyFile { bind: result }); + return Ok(KeyFile { bind, define }); } } } @@ -71,6 +92,9 @@ fn parse_string_helper(file_content: &str) -> std::result::Result Self; fn coalesce(self, new: Self) -> Self; } pub trait Resolving { - fn resolve(self, name: &'static str) -> Result; + fn resolve(self, name: impl Into) -> Result; } pub trait Requiring { - fn require(self, name: &'static str) -> Result; + fn require(self, name: impl Into) -> Result; } // TODO: is there any way to avoid so much copying here @@ -98,16 +100,16 @@ impl Merging for bool { } impl Resolving> for Option { - fn resolve(self, _name: &'static str) -> Result { + fn resolve(self, _name: impl Into) -> Result { return Ok(self); } } impl Requiring for Option { - fn require(self, name: &'static str) -> Result { + fn require(self, name: impl Into) -> Result { match self { Some(x) => Ok(x), - None => Err(Error::RequiredField(name).into()), + None => Err(Error::RequiredField(name.into()).into()), } } } @@ -132,17 +134,17 @@ impl Required> { } impl Resolving for Required { - fn resolve(self, name: &'static str) -> Result { + fn resolve(self, name: impl Into) -> Result { return match self { - Required::DefaultValue => Err(Error::RequiredField(name).into()), + Required::DefaultValue => Err(Error::RequiredField(name.into()).into()), Required::Value(val) => Ok(val), }; } } impl Requiring for Required { - fn require(self, name: &'static str) -> Result { - return self.resolve(name); + fn require(self, name: impl Into) -> Result { + return self.resolve(name.into()); } } @@ -154,6 +156,13 @@ impl Required { }; } + pub fn as_ref(&self) -> Required<&T> { + match *self { + Required::Value(ref x) => Required::Value(x), + Required::DefaultValue => Required::DefaultValue, + } + } + pub fn or(self, new: Self) -> Self { return match new { Required::Value(new_val) => match self { From 2dfbb57e1153588ff6b499001277b85fde33e8dc Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 4 Aug 2025 00:21:18 -0400 Subject: [PATCH 24/79] integrated `define` into `file` Created using spr 1.3.6-beta.1 --- mise.toml | 4 ++-- src/rust/parsing/src/define.rs | 9 ++++--- src/rust/parsing/src/error.rs | 9 +++---- src/rust/parsing/src/file.rs | 43 ++++++++++++++++++++-------------- 4 files changed, 37 insertions(+), 28 deletions(-) diff --git a/mise.toml b/mise.toml index 2e10c5bd..c6804762 100644 --- a/mise.toml +++ b/mise.toml @@ -28,9 +28,9 @@ run = 'tsc --noEmit --project tsconfig.json' # TODO: maybe consider using colons and figure out mise task hierarchies??? [tasks.build-rust] -sources = ['src/rust/parsing/src/**/*.rs', 'src/rust/parsing/Cargo.toml'] -outputs = ['out/**/*.wasm', 'src/rust/parsing/lib/*'] dir = 'src/rust/parsing' +sources = ['src/**/*.rs', 'Cargo.toml'] +outputs = ['lib/*'] run = [ 'wasm-pack build --target web --out-dir lib', 'mkdir -p ../../../out', diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 4022ab3a..36ba3149 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -22,9 +22,12 @@ pub struct DefineInput { #[wasm_bindgen] #[derive(Clone, Debug, Default)] pub struct Define { - bind: Option>, - command: Option>, - var: Option, + #[wasm_bindgen(skip)] + pub bind: Option>, + #[wasm_bindgen(skip)] + pub command: Option>, + #[wasm_bindgen(skip)] + pub var: Option, } #[wasm_bindgen] diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 0a9233b0..7618e229 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -109,17 +109,14 @@ impl fmt::Display for ErrorWithContext { for context in &self.contexts { match context { Context::String(str) => { - write!(f, "{}\n", str); + write!(f, "{}\n", str)?; } Context::Range(range) => { - // TODO: we may evenutally wan to support showing the text - // here. *HOWEVER* this is something we can also do downstream - // with the document class in vscode so probably not necessary - write!(f, "byte range {:?}\n", range); + write!(f, "byte range {:?}\n", range)?; } } } - self.error.fmt(f); + self.error.fmt(f)?; return Ok(()); } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 0825449b..27ae444d 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -16,7 +16,7 @@ struct KeyFileInput { bind: Option>>, } -#[derive(Clone)] +#[derive(Clone, Debug)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct KeyFile { @@ -56,10 +56,10 @@ impl KeyFile { }) .flatten() .unwrap_or_default(); - if !errors.len() > 0 { - return Err(errors); - } else { + if errors.len() == 0 { return Ok(KeyFile { bind, define }); + } else { + return Err(errors); } } } @@ -88,13 +88,10 @@ fn parse_string_helper(file_content: &str) -> std::result::Result(file_content); return match parsed { Ok(input) => KeyFile::new(input), - Err(err) => return Err(vec![err.into()]), + Err(err) => Err(vec![err.into()]), }; } -// TOOD: is there some way to handle JsValue-like objects during the final -// step to make tests easier - #[cfg(test)] mod tests { use super::*; @@ -103,6 +100,9 @@ mod tests { #[test] fn parse_example() { let data = r#" + [define.var] + foo = "bar" + [[bind]] key = "l" mode = "normal" @@ -115,15 +115,24 @@ mod tests { "#; let result = parse_string(data); - assert_eq!(result.file.as_ref().unwrap().bind[0].key, "l"); - assert_eq!( - result.file.as_ref().unwrap().bind[0].commands[0].command, - "cursorRight" - ); - assert_eq!(result.file.as_ref().unwrap().bind[1].key, "h"); + let items = result.file.as_ref().unwrap(); + + assert_eq!(items.bind[0].key, "l"); + assert_eq!(items.bind[0].commands[0].command, "cursorRight"); + assert_eq!(items.bind[1].key, "h"); + assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); + assert_eq!( - result.file.as_ref().unwrap().bind[1].commands[0].command, - "cursorLeft" - ); + items + .define + .var + .as_ref() + .unwrap() + .get("foo") + .unwrap() + .as_str() + .unwrap(), + "bar" + ) } } From a9b5af6bc3446d6d0b7889cc9d08f092fdabd2d4 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 5 Aug 2025 09:26:02 -0400 Subject: [PATCH 25/79] define generic variable expansion Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/bind/foreach.rs | 78 +----------- src/rust/parsing/src/error.rs | 8 +- src/rust/parsing/src/lib.rs | 1 + src/rust/parsing/src/variable.rs | 182 +++++++++++++++++++++++++++ 4 files changed, 189 insertions(+), 80 deletions(-) create mode 100644 src/rust/parsing/src/variable.rs diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index d4c88a0b..059b66f5 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -1,86 +1,10 @@ use crate::error::Result; -use crate::util::{Plural, Required}; use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use toml::{Spanned, Value}; - -pub trait ForeachExpanding { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self; -} - -impl ForeachExpanding for Spanned { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return Spanned::new(self.span(), self.get_ref().expand_foreach_value(var, value)); - } -} - -impl ForeachExpanding for Plural { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - match self { - Plural::Zero => Plural::Zero, - Plural::One(x) => Plural::One(x.expand_foreach_value(var, value)), - Plural::Many(items) => Plural::Many( - items - .iter() - .map(|v| v.expand_foreach_value(var, value)) - .collect(), - ), - } - } -} - -impl ForeachExpanding for Required { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return match self { - Required::DefaultValue => Required::DefaultValue, - Required::Value(x) => Required::Value(x.expand_foreach_value(var, value)), - }; - } -} - -impl ForeachExpanding for toml::map::Map { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - let mut result = toml::map::Map::new(); - for (k, v) in self { - result.insert(k.clone(), v.expand_foreach_value(var, value)); - } - return result; - } -} - -impl ForeachExpanding for toml::Value { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - match self { - Value::String(str) => Value::String(str.expand_foreach_value(var, value)), - Value::Array(items) => Value::Array( - items - .iter() - .map(|i| i.expand_foreach_value(var, value)) - .collect(), - ), - Value::Table(kv) => Value::Table(kv.expand_foreach_value(var, value)), - other => other.clone(), - } - } -} - -impl ForeachExpanding for Option { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return match self { - Some(v) => Some(v.expand_foreach_value(var, value)), - None => None, - }; - } -} - -impl ForeachExpanding for String { - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return self.replace(&format!("{}{var}{}", "{{", "}}"), value); - } -} +use toml::Value; pub trait ForeachInterpolated { fn foreach_interpolation(&self) -> String; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 7618e229..a2a79a9d 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -12,10 +12,12 @@ use core::ops::Range; pub enum Error { #[error("parsing {0}")] Parsing(#[from] toml::de::Error), + #[error("serializing {0}")] + Serialization(#[from] toml::ser::Error), #[error("validating {0}")] Validation(#[from] validator::ValidationError), #[error("expected {0}")] - ConstraintError(&'static str), + Constraint(String), #[error("requires {0}")] RequiredField(String), #[error("unexpected {0}")] @@ -130,8 +132,8 @@ impl> From for ErrorWithContext { } } -pub fn constrain(msg: &'static str) -> Result { - return Err(Error::ConstraintError(msg))?; +pub fn constrain(msg: &str) -> Result { + return Err(Error::Constraint(msg.into()))?; } pub fn unexpected(msg: &'static str) -> Result { diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 01765484..a79e3595 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,6 +1,7 @@ // error reporting pub mod error; mod util; +mod variable; // [[bind]] level parsing mod bind; diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs new file mode 100644 index 00000000..5f7f4a2e --- /dev/null +++ b/src/rust/parsing/src/variable.rs @@ -0,0 +1,182 @@ +use crate::error::{Error, Result}; +use crate::util::{Plural, Required}; + +use lazy_static::lazy_static; +use regex::Regex; +use serde::{Deserialize, Serialize}; +use toml::Spanned; +use validator::{Validate, ValidationError}; + +pub trait VariableExpanding { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()>; +} + +impl VariableExpanding for Spanned { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + self.get_mut().expand_value(var, value)?; + Ok(()) + } +} + +impl VariableExpanding for Plural { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + match self { + Plural::Zero => (), + Plural::One(x) => x.expand_value(var, value)?, + Plural::Many(items) => items + .iter_mut() + .map(|v| v.expand_value(var, value)) + .collect::>()?, + } + return Ok(()); + } +} + +impl VariableExpanding for Required { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + return match self { + Required::DefaultValue => Ok(()), + Required::Value(x) => x.expand_value(var, value), + }; + } +} + +impl VariableExpanding for toml::map::Map { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + return self + .iter_mut() + .map(|(_, v)| v.expand_value(var, value)) + .collect::>(); + } +} + +impl VariableExpanding for toml::Value { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + match self { + toml::Value::String(str) => str.expand_value(var, value)?, + toml::Value::Array(items) => items + .iter_mut() + .map(|i| i.expand_value(var, value)) + .collect::>()?, + toml::Value::Table(kv) => kv.expand_value(var, value)?, + _ => (), + } + + return Ok(()); + } +} + +impl VariableExpanding for Option { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + match self { + Some(v) => v.expand_value(var, value)?, + None => (), + }; + return Ok(()); + } +} + +trait As { + fn astype(&self) -> Option; +} + +impl As for toml::Value { + fn astype(&self) -> Option { + self.as_str().map(|s| s.into()) + } +} + +impl As for toml::Value { + fn astype(&self) -> Option { + self.as_bool() + } +} + +impl As for toml::Value { + fn astype(&self) -> Option { + self.as_integer() + } +} + +impl As for toml::Value { + fn astype(&self) -> Option { + self.as_float() + } +} + +impl As for T +where + T: Clone, +{ + fn astype(&self) -> Option { + Some(self.clone()) + } +} + +#[derive(Deserialize, Clone, Debug)] +#[serde(transparent)] +struct Value(ValueEnum) +where + toml::Value: As; + +#[derive(Deserialize, Clone, Debug)] +#[serde(untagged)] +enum ValueEnum +where + toml::Value: As, +{ + Literal(T), + Variable(String), +} + +lazy_static! { + static ref VAR_STRING: Regex = Regex::new(r"^\{\{(.*)\}\}$").unwrap(); +} + +fn variable_name(x: &str) -> Result<&str> { + let captures = VAR_STRING + .captures(x) + .ok_or_else(|| Error::Constraint(r"string surrounded by `{{` and `}}`".into()))?; + return Ok(captures + .get(1) + .ok_or_else(|| Error::Constraint("variable to be at least one character long".into()))? + .as_str()); +} + +impl VariableExpanding for Value +where + toml::Value: As, + T: Clone, +{ + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + match &self.0 { + ValueEnum::Literal(_) => (), + ValueEnum::Variable(str) => { + let name = variable_name(&str)?; + if name == var { + self.0 = ValueEnum::Literal(As::::astype(value).ok_or_else(|| { + Error::Constraint(format!( + "variable of type `{}`, found {}", + std::any::type_name::(), + value + )) + })?); + } + } + }; + return Ok(()); + } +} + +impl VariableExpanding for String { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + let output = match value { + toml::Value::String(x) => x.clone(), + _ => toml::to_string(value)?, + }; + let new_value = self.replace(&format!("{}{var}{}", "{{", "}}"), &output); + self.clear(); + self.push_str(&new_value); + Ok(()) + } +} From e79c33de5d811a1e6cbbe4773ec7e0ef9cddc265 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 6 Aug 2025 10:28:38 -0400 Subject: [PATCH 26/79] working foreach variable expansion Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 50 ++++++- mise.toml | 1 + src/rust/parsing/src/bind.rs | 189 +++++++++++++++++++-------- src/rust/parsing/src/bind/foreach.rs | 13 -- src/rust/parsing/src/error.rs | 59 +++++++-- src/rust/parsing/src/file.rs | 2 +- src/rust/parsing/src/util.rs | 2 - src/rust/parsing/src/variable.rs | 56 +++++++- 8 files changed, 289 insertions(+), 83 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 2450edfb..1e1e051e 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,8 +9,54 @@ "rust-analyzer.linkedProjects": [ "src/rust/parsing/Cargo.toml" ], - "workbench.colorCustomizations": {}, - "window.title": "${activeEditorShort}${separator}${rootName}${separator}${profileName}", + "workbench.colorCustomizations": { + "editorBracketHighlight.foreground1": "#1b9e77", + "editorBracketHighlight.foreground2": "#d95f02", + "editorBracketHighlight.foreground3": "#7570b3", + "editorBracketHighlight.foreground4": "#e7298a", + "editorBracketHighlight.foreground5": "#66a61e", + "editorBracketHighlight.foreground6": "#e6ab02", + "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", + "statusBarItem.warningBackground": "#da0ba3", + "statusBarItem.warningForeground": "#ffffff", + "statusBarItem.warningHoverBackground": "#da0ba3", + "statusBarItem.warningHoverForeground": "#ffffff90", + "statusBarItem.remoteBackground": "#e718b0", + "statusBarItem.remoteForeground": "#ffffff", + "statusBarItem.remoteHoverBackground": "#f425bd", + "statusBarItem.remoteHoverForeground": "#ffffff90", + "statusBar.background": "#da0ba3", + "statusBar.foreground": "#ffffff", + "statusBar.border": "#da0ba3", + "statusBar.debuggingBackground": "#da0ba3", + "statusBar.debuggingForeground": "#ffffff", + "statusBar.debuggingBorder": "#da0ba3", + "statusBar.noFolderBackground": "#da0ba3", + "statusBar.noFolderForeground": "#ffffff", + "statusBar.noFolderBorder": "#da0ba3", + "statusBar.prominentBackground": "#da0ba3", + "statusBar.prominentForeground": "#ffffff", + "statusBar.prominentHoverBackground": "#da0ba3", + "statusBar.prominentHoverForeground": "#ffffff90", + "focusBorder": "#da0ba399", + "progressBar.background": "#da0ba3", + "textLink.foreground": "#ff4be3", + "textLink.activeForeground": "#ff58f0", + "selection.background": "#cd0096", + "list.highlightForeground": "#da0ba3", + "list.focusAndSelectionOutline": "#da0ba399", + "button.background": "#da0ba3", + "button.foreground": "#ffffff", + "button.hoverBackground": "#e718b0", + "tab.activeBorderTop": "#e718b0", + "pickerGroup.foreground": "#e718b0", + "list.activeSelectionBackground": "#da0ba34d", + "panelTitle.activeBorder": "#e718b0", + "activityBar.activeBorder": "#da0ba3", + "activityBarBadge.foreground": "#ffffff", + "activityBarBadge.background": "#da0ba3" + }, + "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", "projectColors.mainColor": "#681dd7", "projectColors.isActivityBarColored": false, diff --git a/mise.toml b/mise.toml index c6804762..d97b8ae7 100644 --- a/mise.toml +++ b/mise.toml @@ -44,6 +44,7 @@ coverage_options = '''--ignore-filename-regex '/.cargo/registry' --ignore-filena [tasks.test-rust] dir = 'src/rust/parsing' shell = 'nu -c' +env.RUST_BACKTRACE = "1" run = ''' def main [...args] { if ($env.COVERAGE? | default false | into bool) { diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index a84f6a6f..81b0dc83 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -5,10 +5,12 @@ mod foreach; mod validation; -use crate::bind::foreach::{ForeachExpanding, ForeachInterpolated, expand_keys}; +use crate::bind::foreach::expand_keys; use crate::bind::validation::{JsonObjectShape, valid_json_array_object, valid_key_binding}; use crate::error::{Context, ErrorContext, Result, constrain, unexpected}; use crate::util::{Merging, Plural, Required, Requiring, Resolving}; +use crate::variable; +use crate::variable::VariableExpanding; #[allow(unused_imports)] use log::info; @@ -67,7 +69,7 @@ pub struct BindingInput { * - `command`*: A string denoting the command to execute. This is a command * defined by VSCode or an extension thereof. * See [finding commands](#finding-commands). This field has special - * behavior for the command `runCommands` + * behavior when set to`runCommands` * (see [running multiple commands](#running-multiple-commands)). */ #[serde(default = "span_required_default")] @@ -120,7 +122,7 @@ pub struct BindingInput { * bindings take precedence. Defaults to 0. */ #[serde(default)] - pub priority: Option>, + pub priority: Option>>, /** * @forBindingField bind * @@ -162,7 +164,7 @@ pub struct BindingInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - pub finalKey: Option>, + pub finalKey: Option>>, /** * @forBindingField bind @@ -211,9 +213,9 @@ pub struct BindingInput { * and the documentation. These both default to false. */ #[serde(default)] - pub hideInPalette: Option>, + pub hideInPalette: Option>>, #[serde(default)] - pub hideInDocs: Option>, + pub hideInDocs: Option>>, /** * @forBindingField bind @@ -308,6 +310,7 @@ impl Command { } } +// TODO: have Value and Value #[derive(Clone, Debug, Serialize)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] @@ -323,14 +326,16 @@ pub struct Binding { pub repeat: Option, pub name: Option, pub description: Option, - pub hideInPalette: Option, - pub hideInDocs: Option, + pub hideInPalette: bool, + pub hideInDocs: bool, pub combinedName: Option, pub combinedKey: Option, pub combinedDescription: Option, pub kind: Option, } +// TODO: define functions for variable expansion on `Binding??` + // TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error impl BindingInput { @@ -362,16 +367,21 @@ impl BindingInput { final_foreach.remove(var); if let Value::Array(items) = values { - let expanded_items = expand_keys(items) - .context(Context::String(format!("while reading {}", values)))?; + let expanded_items = + expand_keys(items).context_str(format!("while reading {}", values))?; let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); for input in inputs { for value in &expanded_items { - let str = value.foreach_interpolation(); - result.push(input.expand_foreach_value(var, &str)); + let mut expanded = input.clone(); + expanded.expand_value(var, value)?; + result.push(expanded); } } - self.foreach = Some(Spanned::new(UNKNOWN_RANGE, final_foreach)); + if final_foreach.len() > 0 { + self.foreach = Some(Spanned::new(UNKNOWN_RANGE, final_foreach)); + } else { + self.foreach = None; + } return Ok(result); } else { return unexpected("`foreach` was not an object of arrays"); @@ -380,29 +390,83 @@ impl BindingInput { return Ok(vec![]); } } +} - fn expand_foreach_value(&self, var: &str, value: &str) -> Self { - return BindingInput { - command: self.command.expand_foreach_value(var, value), - args: self.args.expand_foreach_value(var, value), - key: self.key.expand_foreach_value(var, value), - when: self.when.expand_foreach_value(var, value), - mode: self.mode.expand_foreach_value(var, value), - priority: self.priority.clone(), - defaults: self.defaults.expand_foreach_value(var, value), - prefixes: self.prefixes.expand_foreach_value(var, value), - finalKey: self.finalKey.clone(), - repeat: self.repeat.expand_foreach_value(var, value), - foreach: None, - name: self.name.expand_foreach_value(var, value), - description: self.description.expand_foreach_value(var, value), - hideInPalette: self.hideInPalette.clone(), - hideInDocs: self.hideInDocs.clone(), - combinedName: self.combinedName.expand_foreach_value(var, value), - combinedKey: self.combinedKey.expand_foreach_value(var, value), - combinedDescription: self.combinedDescription.expand_foreach_value(var, value), - kind: self.kind.expand_foreach_value(var, value), - }; +impl VariableExpanding for BindingInput { + fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + self.command + .expand_value(var, value) + .context_str("`command` field") + .context_range(&self.command)?; + self.args + .expand_value(var, value) + .context_str("`args` field") + .context_range(&self.args)?; + self.key + .expand_value(var, value) + .context_str("`key` field") + .context_range(&self.key)?; + self.when + .expand_value(var, value) + .context_str("`when` field") + .context_range(&self.when)?; + self.mode + .expand_value(var, value) + .context_str("`mode` field") + .context_range(&self.mode)?; + self.priority + .expand_value(var, value) + .context_str("`priority` field") + .context_range(&self.priority)?; + self.defaults + .expand_value(var, value) + .context_str("`defaults` field") + .context_range(&self.defaults)?; + self.prefixes + .expand_value(var, value) + .context_str("`prefixes` field") + .context_range(&self.prefixes)?; + self.finalKey + .expand_value(var, value) + .context_str("`finalKey` field") + .context_range(&self.finalKey)?; + self.repeat + .expand_value(var, value) + .context_str("`repeat` field") + .context_range(&self.repeat)?; + self.name + .expand_value(var, value) + .context_str("`name` field") + .context_range(&self.name)?; + self.description + .expand_value(var, value) + .context_str("`description` field") + .context_range(&self.description)?; + self.hideInPalette + .expand_value(var, value) + .context_str("`hideInPalette` field") + .context_range(&self.hideInPalette)?; + self.hideInDocs + .expand_value(var, value) + .context_str("`hideInDocs` field") + .context_range(&self.hideInDocs)?; + self.combinedName + .expand_value(var, value) + .context_str("`combinedName` field") + .context_range(&self.combinedName)?; + self.combinedKey + .expand_value(var, value) + .context_str("`combinedKey` field") + .context_range(&self.combinedKey)?; + self.combinedDescription + .expand_value(var, value) + .context_str("`combinedDescription` field") + .context_range(&self.combinedDescription)?; + self.kind + .expand_value(var, value) + .context_str("`kind` field") + .context_range(&self.kind)?; + return Ok(()); } } @@ -413,19 +477,15 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Result<(BindingInput, Vec 1".into())); assert_eq!(result.mode.into_inner(), Plural::One("normal".into())); - assert_eq!(result.priority.map(|x| x.into_inner()).unwrap(), 1); + assert_eq!(result.priority.map(|x| x.into_inner()).unwrap().unwrap(), 1); assert_eq!(result.defaults.map(|x| x.into_inner()).unwrap(), "foo.bar"); assert_eq!( result.foreach.unwrap().into_inner().get("index").unwrap(), &Value::Array(vec![1, 2, 3].iter().map(|x| Value::Integer(*x)).collect()) ); assert_eq!(result.prefixes.into_inner(), Plural::One("c".into())); - assert_eq!(result.finalKey.map(|x| x.into_inner()).unwrap(), true); + assert_eq!( + result.finalKey.map(|x| x.into_inner()).unwrap().unwrap(), + true + ); assert_eq!(result.name.map(|x| x.into_inner()).unwrap(), "foo"); assert_eq!( result.description.map(|x| x.into_inner()).unwrap(), "foo bar bin" ); - assert_eq!(result.hideInDocs.map(|x| x.into_inner()).unwrap(), false); - assert_eq!(result.hideInPalette.map(|x| x.into_inner()).unwrap(), false); + assert_eq!( + result.hideInDocs.map(|x| x.into_inner()).unwrap().unwrap(), + false + ); + assert_eq!( + result + .hideInPalette + .map(|x| x.into_inner()) + .unwrap() + .unwrap(), + false + ); assert_eq!( result.combinedName.map(|x| x.into_inner()).unwrap(), "Up/down" diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 059b66f5..ad8d0e9d 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -6,19 +6,6 @@ use log::info; use regex::Regex; use toml::Value; -pub trait ForeachInterpolated { - fn foreach_interpolation(&self) -> String; -} - -impl ForeachInterpolated for Value { - fn foreach_interpolation(&self) -> String { - match self { - Value::String(str) => str.clone(), - _ => format!("{}", self), - } - } -} - const ALL_KEYS: [&'static str; 192] = [ "f0", "f1", diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index a2a79a9d..852daa41 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,11 +1,12 @@ +use crate::bind::UNKNOWN_RANGE; + +use core::ops::Range; use std::fmt; use string_offsets::{Pos, StringOffsets}; use thiserror::Error; +use toml::Spanned; use wasm_bindgen::prelude::*; -use crate::bind::UNKNOWN_RANGE; -use core::ops::Range; - // TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) #[derive(Debug, Error, Clone)] @@ -22,6 +23,8 @@ pub enum Error { RequiredField(String), #[error("unexpected {0}")] Unexpected(&'static str), + #[error("unresolved {0}")] + Unresolved(String), #[error("parsing regex failed with {0}")] Regex(#[from] regex::Error), } @@ -69,10 +72,15 @@ impl ErrorWithContext { message: Some(str.clone()), range: None, }, - Context::Range(range) => ErrorReportItem { - message: None, - range: Some(range_to_pos(range.clone(), &offsets)), - }, + Context::Range(range) => { + if *range == UNKNOWN_RANGE { + continue; + } + ErrorReportItem { + message: None, + range: Some(range_to_pos(range.clone(), &offsets)), + } + } }; items.push(item); } @@ -140,8 +148,43 @@ pub fn unexpected(msg: &'static str) -> Result { return Err(Error::Unexpected(msg))?; } -pub trait ErrorContext { +pub trait ErrorContext +where + Self: Sized, +{ fn context(self, context: Context) -> Result; + fn context_str(self, context: impl Into) -> Result { + self.context(Context::String(context.into())) + } + fn context_range(self, context: &impl Spannable) -> Result { + if let Some(range) = context.range() { + return self.context(Context::Range(range)); + } else { + return self.context(Context::Range(UNKNOWN_RANGE)); + } + } +} + +pub trait Spannable { + fn range(&self) -> Option>; +} + +impl Spannable for Spanned { + fn range(&self) -> Option> { + Some(self.span()) + } +} + +impl Spannable for Option> { + fn range(&self) -> Option> { + self.as_ref().map(|x| x.span()) + } +} + +impl Spannable for Range { + fn range(&self) -> Option> { + return Some(self.clone()); + } } impl> ErrorContext for std::result::Result { diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 27ae444d..c992911f 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -35,7 +35,7 @@ impl KeyFile { .filter_map(|b| { let span = b.span(); Binding::new(b.into_inner()) - .context(Context::Range(span)) + .context_range(&span) .map_err(|e| errors.push(e)) .ok() }) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index de495811..9a5a6a4a 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -5,9 +5,7 @@ use crate::{ use log::info; use serde::{Deserialize, Serialize}; -use serde_wasm_bindgen; use toml::{Spanned, Value}; -use wasm_bindgen::JsValue; pub trait Merging { fn merge(self, new: Self) -> Self; diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index 5f7f4a2e..8eb93876 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -1,5 +1,8 @@ use crate::error::{Error, Result}; -use crate::util::{Plural, Required}; +use crate::util::{Merging, Plural, Required, Resolving}; + +#[allow(unused_imports)] +use log::info; use lazy_static::lazy_static; use regex::Regex; @@ -115,15 +118,17 @@ where #[derive(Deserialize, Clone, Debug)] #[serde(transparent)] -struct Value(ValueEnum) +pub struct Value(ValueEnum) where - toml::Value: As; + toml::Value: As, + T: Copy; #[derive(Deserialize, Clone, Debug)] #[serde(untagged)] enum ValueEnum where toml::Value: As, + T: Copy, { Literal(T), Variable(String), @@ -146,7 +151,7 @@ fn variable_name(x: &str) -> Result<&str> { impl VariableExpanding for Value where toml::Value: As, - T: Clone, + T: Copy, { fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { match &self.0 { @@ -168,11 +173,52 @@ where } } +impl Merging for Value +where + toml::Value: As, + T: Copy, +{ + fn coalesce(self, new: Self) -> Self { + return new; + } + + fn merge(self, new: Self) -> Self { + return new; + } +} + +impl Value +where + T: Copy, + toml::Value: As, +{ + pub fn unwrap(self) -> T { + return match self.0 { + ValueEnum::Literal(x) => x, + ValueEnum::Variable(_) => panic!("Expected literal value"), + }; + } +} + +impl Resolving for Value +where + T: Copy, + toml::Value: As, +{ + fn resolve(self, name: impl Into) -> Result { + return match self.0 { + ValueEnum::Literal(x) => Ok(x), + ValueEnum::Variable(str) => { + Err(Error::Unresolved(format!("{str} for {}", name.into())))? + } + }; + } +} impl VariableExpanding for String { fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { let output = match value { toml::Value::String(x) => x.clone(), - _ => toml::to_string(value)?, + _ => value.to_string(), }; let new_value = self.replace(&format!("{}{var}{}", "{{", "}}"), &output); self.clear(); From 1e57d7506b139cf5d6d7c59006587d03dbf7eb2d Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 13 Aug 2025 07:53:21 -0400 Subject: [PATCH 27/79] poc for define variable resolution Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 76 +-- notes.md | 15 +- src/presets/larkin.toml | 734 ++++++++++++++------------- src/rust/parsing/Cargo.lock | 99 ++-- src/rust/parsing/Cargo.toml | 2 +- src/rust/parsing/src/bind.rs | 131 +++-- src/rust/parsing/src/bind/foreach.rs | 2 +- src/rust/parsing/src/define.rs | 394 +++++++++----- src/rust/parsing/src/error.rs | 54 +- src/rust/parsing/src/file.rs | 68 +-- src/rust/parsing/src/util.rs | 4 +- src/rust/parsing/src/variable.rs | 242 ++++++--- 12 files changed, 1096 insertions(+), 725 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 1e1e051e..c19905e2 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#da0ba3", - "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#da0ba3", - "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#e718b0", - "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#f425bd", - "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#da0ba3", - "statusBar.foreground": "#ffffff", - "statusBar.border": "#da0ba3", - "statusBar.debuggingBackground": "#da0ba3", - "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#da0ba3", - "statusBar.noFolderBackground": "#da0ba3", - "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#da0ba3", - "statusBar.prominentBackground": "#da0ba3", - "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#da0ba3", - "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#da0ba399", - "progressBar.background": "#da0ba3", - "textLink.foreground": "#ff4be3", - "textLink.activeForeground": "#ff58f0", - "selection.background": "#cd0096", - "list.highlightForeground": "#da0ba3", - "list.focusAndSelectionOutline": "#da0ba399", - "button.background": "#da0ba3", - "button.foreground": "#ffffff", - "button.hoverBackground": "#e718b0", - "tab.activeBorderTop": "#e718b0", - "pickerGroup.foreground": "#e718b0", - "list.activeSelectionBackground": "#da0ba34d", - "panelTitle.activeBorder": "#e718b0", - "activityBar.activeBorder": "#da0ba3", - "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#da0ba3" + "statusBarItem.warningBackground": "#43f90b", + "statusBarItem.warningForeground": "#000000", + "statusBarItem.warningHoverBackground": "#43f90b", + "statusBarItem.warningHoverForeground": "#00000090", + "statusBarItem.remoteBackground": "#50ff18", + "statusBarItem.remoteForeground": "#000000", + "statusBarItem.remoteHoverBackground": "#5dff25", + "statusBarItem.remoteHoverForeground": "#00000090", + "statusBar.background": "#43f90b", + "statusBar.foreground": "#000000", + "statusBar.border": "#43f90b", + "statusBar.debuggingBackground": "#43f90b", + "statusBar.debuggingForeground": "#000000", + "statusBar.debuggingBorder": "#43f90b", + "statusBar.noFolderBackground": "#43f90b", + "statusBar.noFolderForeground": "#000000", + "statusBar.noFolderBorder": "#43f90b", + "statusBar.prominentBackground": "#43f90b", + "statusBar.prominentForeground": "#000000", + "statusBar.prominentHoverBackground": "#43f90b", + "statusBar.prominentHoverForeground": "#00000090", + "focusBorder": "#43f90b99", + "progressBar.background": "#43f90b", + "textLink.foreground": "#83ff4b", + "textLink.activeForeground": "#90ff58", + "selection.background": "#36ec00", + "list.highlightForeground": "#43f90b", + "list.focusAndSelectionOutline": "#43f90b99", + "button.background": "#43f90b", + "button.foreground": "#000000", + "button.hoverBackground": "#50ff18", + "tab.activeBorderTop": "#50ff18", + "pickerGroup.foreground": "#50ff18", + "list.activeSelectionBackground": "#43f90b4d", + "panelTitle.activeBorder": "#50ff18", + "activityBar.activeBorder": "#43f90b", + "activityBarBadge.foreground": "#000000", + "activityBarBadge.background": "#43f90b" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/notes.md b/notes.md index ca6efeb8..56e46433 100644 --- a/notes.md +++ b/notes.md @@ -89,13 +89,18 @@ Integration test debugging: - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] expansion of `[define]` sections - - [ ] unit tests for `define` parsing - - [ ] get basic interpolation of `{{var}}` elements working for `bind` and its fields + - [X] implement support for resolving `var.`, `command.` and `bind.` definitions + - [X] problem: spannd doesn't work with flatten; we can solve this by + creating an `id` field for `command` and `bind` that will throw + an error if populatd when passed on to the non-input constructors + - [~] unit tests for `define` parsing + - [ ] get basic interpolation of `{{var}}` from `define` elements working for `bind` and its fields + - [ ] implement `default` keyword for `bind` - [ ] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - - [ ] foreach expansion + - [ ] foreach expansion within a KeyFile context - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls @@ -106,13 +111,13 @@ Integration test debugging: - [ ] modes are all positive or negative - [ ] required keys are present - [ ] mode expansion + - [ ] key-sequence expansion and duplicate resolution - [ ] documentation expandsion/validation across all `[[bind]]` values with the same key and mode - - [ ] key-sequence expansion and duplicate resolution - - [ ] proper parsing and expansion of `[[define]]` sections - [ ] proper conversion to keybindings.json command - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause + - [ ] extraction of visual docs - [ ] extraction of markdown docs - [ ] extract all comment regions (exclude `#-`) - [ ] replace `[[bind]]` regions: diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 7b8b6b63..ff7effe4 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -56,8 +56,8 @@ name = "selectedit" highlight = "Highlight" cursorShape = "BlockOutline" -[define.var] -select_on = false +[[define.var]] +select = false [[kind]] name = "motion" @@ -77,7 +77,8 @@ description = """ Assorted other commands that aren't motions or actions """ -[define.command.selectLinesDown] +[[define.command]] +id = "selectLinesDown" command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", @@ -86,7 +87,8 @@ args.commands = [ "selection-utilities.exchangeAnchorActive", ] -[define.command.selectLinesUp] +[[define.command]] +id = "selectLinesUp" command = "selection-utilities.shrinkToActive" args.commands = [ "selection-utilities.shrinkToActive", @@ -94,7 +96,8 @@ args.commands = [ "expandLineSelection", ] -[define.bind.modes] +[[define.bind]] +id = "modes" kind = "util" # ## Getting Help @@ -106,7 +109,7 @@ kind = "util" # 3. The suggestion palette shows a list of the current bindings given the current key binding prefix. [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" key = "shift+;" name = "suggest" finalKey = false @@ -148,7 +151,7 @@ command = "master-key.showVisualDoc" # While in Normal model you will see a highlighted section with the text "normal" in the lower left hand corner of the status bar. [[bind]] -merge = "{{bind.modes}}" +default = "{{bind.modes}}" name = "normal" description = "Enter normal mode" foreach.key = ["escape", "ctrl+["] @@ -164,7 +167,7 @@ when = "!findWidgetVisible" prefixes = "{{all_prefixes}}" [[bind]] -merge = "{{bind.modes}}" +default = "{{bind.modes}}" name = "normal" foreach.key = ["escape", "ctrl+["] key = "{{key}}" @@ -178,12 +181,12 @@ prefixes = "{{all_prefixes}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect [[bind]] -merge = "{{bind.modes}}" +default = "{{bind.modes}}" name = "ignore" description = "this key does nothing" foreach.key = [ - '{{key: .}}', - 'shift+{{key: .}}', + '{{key(`.`)}}', + 'shift+{{key(`.`)}}', ] #- all keys whose bindings are described by a single character key = "{{key}}" command = "master-key.ignore" @@ -194,12 +197,14 @@ hideInDocs = true hideInPalette = true priority = -10 -[define.bind.edit] +[[define.bind]] +id = "edit" when = "editorTextFocus && !findWidgetVisible" mode = "normal" -[define.bind.edit_count] -merge = "{{bind.edit}}" +[[define.bind]] +id = "edit_count" +default = "{{bind.edit}}" kind = "count" # ## Basic motions @@ -208,19 +213,21 @@ kind = "count" # Selection behavior uses the following logic: motions that move more than one character generally select the text "under" the motion. If a selection already exists (e.g. from a previous motion) additional motions extend that selection. You can always reset the selection using `v`, and several commands (e.g. `x`) operate on the next character rather than the current selection. -[define.bind.edit_motion] -merge = "{{bind.edit}}" +[[define.bind]] +id = "edit_motion" +default = "{{bind.edit}}" kind = "motion" tags = ["motion"] -[define.bind.edit_motion_prim] -merge = "{{bind.edit_motion}}" +[[define.bind]] +id = "edit_motion_prim" +default = "{{bind.edit_motion}}" command = "cursorMove" value = "{{count}}" -select = "{{editorHasSelection || var.select_on}}" +select = "{{editorHasSelection || var.select}}" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "h" name = "←" combinedName = "←/→" @@ -231,7 +238,7 @@ args.to = "left" mode = "normal" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "l" combinedName = "←/→" name = "→" @@ -239,7 +246,7 @@ description = "move right" args.to = "right" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "j" name = "↓" combinedName = "↓/↑" @@ -250,7 +257,7 @@ args.to = "down" args.by = "wrappedLine" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "k" name = "↑" description = "move up" @@ -259,7 +266,7 @@ args.to = "up" args.by = "wrappedLine" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "shift+h" name = "start" description = "start of line (alternates between first non-white and first)" @@ -269,7 +276,7 @@ combinedDescription = "move to start/end of line" command = "cursorHomeSelect" [[bind]] # we don't use prim because we don't want the defaults -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "shift+l" name = "end" combinedName = "start/end" @@ -279,7 +286,7 @@ args.to = "wrappedLineEnd" args.select = true [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "shift+k" name = "sel ↑" combinedName = "sel ↑/↓" @@ -302,7 +309,7 @@ command = "expandLineSelection" command = "selection-utilities.exchangeAnchorActive" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "shift+j" name = "sel ↓" combinedName = "sel ↑/↓" @@ -320,7 +327,7 @@ args = { to = "down", by = "wrappedLine", select = true, value = "count" } command = "expandLineSelection" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "ctrl+d" mode = ["normal", "insert"] name = "pg ↓" @@ -334,7 +341,7 @@ args.count = "{{(count || 1)/3}}" args.select = "{{mode == 'normal'}}" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "ctrl+u" mode = ["normal", "insert"] name = "pg ↑" @@ -346,20 +353,21 @@ args.count = "{{(count || 1)/3}}" args.select = "{{mode == 'normal'}}" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "shift+x" name = "exapand" description = "expand selections to full lines" command = "expandLineSelection" repeat = "{{count}}" -[define.bind.edit_motion_obj] +[[define.bind]] +id = "edit_motion_obj" command = "selection-utilities.moveBy" args.boundary = "start" args.select = true [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "w" name = "subwrd →" description = "next subword (camel/snake case)" @@ -370,7 +378,7 @@ args.unit = "subword" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "b" name = "subwrd ←" description = "previous subword (camel/snake case)" @@ -379,7 +387,7 @@ args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+w" name = "word →" description = "next word" @@ -390,7 +398,7 @@ args.unit = "word" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+b" name = "word ←" combinedName = "word ←/→" @@ -399,7 +407,7 @@ args.unit = "word" args.value = "{{-count || -1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "e" name = "subwrd end" description = "next subword (camel/snake case) end" @@ -408,7 +416,7 @@ args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+e" name = "word end" description = "next word end" @@ -417,7 +425,7 @@ args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+]" name = "parag. →" description = "next paragraph" @@ -428,7 +436,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+[" name = "parag. ←" combinedName = "paragraph →/←" @@ -437,7 +445,7 @@ args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+0" name = "subsec →" description = "next subsection" @@ -448,7 +456,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+9" name = "subsec ←" description = "previous subsection" @@ -457,7 +465,7 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "v" name = "shrink selection" combinedName = "shrink/hold selection" @@ -470,11 +478,11 @@ reduce all selections to length zero command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "var.select_on", value = false } }, + { command = "master-key.setFlag", args = { name = "var.select", value = false } }, ] [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "shift+v" name = "hold selection" combinedName = "shrink/hold selection" @@ -482,11 +490,11 @@ description = """ all motions extend the selection """ command = "master-key.setFlag" -args.name = "var.select_on" +args.name = "var.select" args.value = true [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "open, act →" description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" key = "o" @@ -501,14 +509,14 @@ command = "runCommands" args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "o" combinedName = "open below/above, act →/←" when = "editorHasSelection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -518,7 +526,7 @@ command = "runCommands" args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "open blw, act ←" combinedName = "open below/above, act →/←" description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" @@ -527,14 +535,14 @@ when = "editorHasSelection" command = "selection-utilities.activeAtStart" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "shift+5" name = "to bracket" description = "Move to matching bracket" command = "editor.action.jumpToBracket" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = '\' name = "→ sel" combinedName = "→/← sel" @@ -552,7 +560,7 @@ command = "cursorMove" args = { to = "right", select = true, value = "{{count}}" } [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = 'shift+\' name = "← sel" combinedName = "→/← sel" @@ -568,21 +576,21 @@ command = "cursorMove" args = { to = "left", select = true, value = "{{count}}" } [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "shift+4" name = "all" description = "Select entire document" command = "editor.action.selectAll" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "shift+r" name = "trim wht" description = "trim external whitespace" command = "selection-utilities.trimSelectionWhitespace" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" name = "→ num." description = "Move to next number" key = "shift+3" @@ -595,7 +603,7 @@ args.boundary = "both" args.value = "{{(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" name = "← num." description = "Move to next number" key = "shift+2" @@ -606,7 +614,7 @@ args.boundary = "both" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = 'narrow to subword' description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" key = "z" @@ -621,7 +629,7 @@ args.boundary = "both" # times e.g. 2w would select the next two words starting from the current cursor position. [[bind]] -foreach.num = ['{{key: [0-9]}}'] +foreach.num = ['{{key(`[0-9]`)}}'] name = "count {{num}}" key = "{{num}}" command = "master-key.updateCount" @@ -637,7 +645,7 @@ hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = ";" name = "repeat motion" description = """ @@ -645,14 +653,14 @@ Repeat the last motion command. Motions usually move the cursor or change the se """ repeat = "{{count}}" command = "master-key.replayFromHistory" -args.whereComputedIndexIs = """ +args.whereIndexIs = """{{ commandHistory[index].tags.contains('motion') && commandHistory[index].name != 'repeat motion' && commandHistory[index].name != 'shrink selection' -""" +}}""" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "repeat subject" description = """ Repeat the subject: a motion command that occurred right before an action. For @@ -661,15 +669,15 @@ last subject until some new action is run after `d`. See also `.` which repeats """ key = "," command = "master-key.replayFromHistory" -args.whereComputedIndexIs = """ +args.whereIndexIs = """{{ commandHistory[index].tags.contains("motion") && commandHistory[index+1].tags.contains("action") && !(commandHistory[index+1].name.startsWith("repeat") && commandHistory[index+1].tags.contains("history")) -""" +}}""" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "cursor undo" key = "-" combinedName = "cursor undo/redo" @@ -677,14 +685,14 @@ combinedKey = "-/shift+-" command = "cursorUndo" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "cursor redo" combinedName = "cursor undo/redo" key = "shift+-" command = "cursorRedo" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "nav ←" description = "Go back in navigation history (e.g. goto definition)" combinedName = "nav ←/→" @@ -694,7 +702,7 @@ key = "g n" command = "workbench.action.navigateBackInNavigationLocations" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "nav →" combinedName = "nav ←/→" description = "Go forward in navigation history (e.g. goto definition)" @@ -702,7 +710,7 @@ key = "g shift+n" command = "workbench.action.navigateForwardInNavigationLocations" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "edit hist ←" description = "Go back in edit history" key = "g -" @@ -712,7 +720,7 @@ combinedDescription = "Go back/forward in edit history" command = "workbench.action.navigateBackInEditLocations" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "edit hist →" description = "Go forward in edit history)" key = "g shift+-" @@ -725,8 +733,9 @@ command = "workbench.action.navigateForwardInEditLocations" # # > I want some food -[define.bind.edit_motion_search] -merge = "{{bind.edit_motion}}" +[[define.bind]] +id = "edit_motion_search" +default = "{{bind.edit_motion}}" command = "master-key.search" args.caseSensitive = false args.backwards = false @@ -734,7 +743,7 @@ args.selectTillMatch = true args.wrapAround = true [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "/" name = "search →" description = "search forwards" @@ -745,7 +754,7 @@ args.offset = "start" args.register = "search" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+/" name = "search ←" description = "search backwards" @@ -755,7 +764,7 @@ args.register = "search" args.backwards = true [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "n" name = "→ search" description = "Go to the next match of the search query" @@ -764,7 +773,7 @@ args.register = "search" args.repeat = "{{(count || 1)-1}}" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+n" name = "← search" description = "Go to the previous match of the search query" @@ -773,7 +782,7 @@ args.register = "search" args.repeat = "{{(count || 1)-1}}" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+8" name = "match →" description = "Next match to object under cursor" @@ -785,7 +794,7 @@ args.offset = "start" args.register = "search" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+7" name = "match ←" description = "Previous match to object under cursor" @@ -796,7 +805,7 @@ args.register = "search" args.backwards = true [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "f" name = "find char" description = "Find the next char (include char in selection)" @@ -808,7 +817,7 @@ args.skip = "{{count-1}}" args.offset = "inclusive" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+f" name = "find char back" description = "Find the previous char (include char in selection)" @@ -819,7 +828,7 @@ args.backwards = true args.skip = "{{count-1}}" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "t" name = "to char" description = "Find the next char (exclude char in selection)" @@ -831,7 +840,7 @@ args.offset = "start" args.skip = "{{count-1}}" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+t" name = "to char back" description = "Find the previous char (exclude char in selection)" @@ -842,7 +851,7 @@ args.backwards = true args.skip = "{{count-1}}" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "s" name = "find char pair" description = "To next character pair" @@ -855,7 +864,7 @@ args.skip = "{{count-1}}" mode = "normal" [[bind]] -merge = "{{bind.edit_motion_search}}" +default = "{{bind.edit_motion_search}}" key = "shift+s" name = "char pair back" description = "To previous character pair" @@ -871,7 +880,7 @@ args.backwards = true # motion commands that compliment the basic motions listed in the previous section. [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "g" priority = 1 name = "goto" @@ -882,7 +891,7 @@ or backwards in some direction. """ [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g j" priority = 1 name = "unwrp ↓" @@ -900,7 +909,7 @@ args.to = "down" args.by = "line" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g k" priority = 1 name = "unwrp ↑" @@ -910,7 +919,7 @@ args.to = "up" args.by = "line" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g shift+k" priority = 1 combinedName = "unwrp sel ↑/↓" @@ -932,7 +941,7 @@ args = { to = "up", by = "line", select = true, value = "{{count}}" } command = "expandLineSelection" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g shift+j" priority = 1 name = "sel ↓" @@ -952,7 +961,7 @@ args = { to = "down", by = "line", select = true, value = "{{count}}" } command = "expandLineSelection" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "shift+g" priority = 1 name = "doc end" @@ -963,7 +972,7 @@ combinedKey = ",/." command = "cursorBottomSelect" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -986,7 +995,7 @@ args.at = "center" args.lineNumber = "{{count}}" [[bind]] -merge = "{{bind.edit_motion_prim}}" +default = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 name = "doc start" @@ -995,7 +1004,7 @@ command = "cursorTopSelect" when = "master-key.count <= 1" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "g w" priority = 1 name = "WORD →" @@ -1009,7 +1018,7 @@ args.unit = "BigWord" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "g b" priority = 1 name = "WORD ←" @@ -1019,7 +1028,7 @@ args.unit = "BigWord" args.value = "{{-count || -1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "g e" priority = 1 name = "WORD end →" @@ -1029,7 +1038,7 @@ args.boundary = "end" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "g 0" priority = 1 name = "sec →" @@ -1041,7 +1050,7 @@ args.unit = "section" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_obj}}" +default = "{{bind.edit_motion_obj}}" key = "g 9" priority = 1 name = "sec ←" @@ -1051,7 +1060,7 @@ args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "goto line" priority = 1 description = "goto line command" @@ -1059,7 +1068,7 @@ key = "g l" command = "workbench.action.gotoLine" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "to refs" priority = 1 description = "jump to a location where this symbol is referenced" @@ -1067,7 +1076,7 @@ key = "g r" command = "editor.action.goToReferences" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "go to" priority = 1 description = "go to the definition of symbol under cursor" @@ -1078,7 +1087,7 @@ combinedDescription = "go to the definition of symbol (in an editor to the side) command = "editor.action.revealDefinition" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "go to, aside" priority = 1 description = "go to the definition of symbol under cursor in an editor to the side" @@ -1087,14 +1096,14 @@ combinedName = "go to (aside)" command = "editor.action.revealDefinitionAside" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "open" description = "open the file name under the cursor" key = "g f" command = "extension.openFileFromPath" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "g c" name = "cell →" combinedName = "cell →/←" @@ -1103,7 +1112,7 @@ args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] description = "previous jupyter notebook cell" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "g shift+c" name = "cell ←" combinedName = "cell →/←" @@ -1117,15 +1126,16 @@ args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] # If you accidentally select `around` instead of `in`, you can revise your selection using `R` to narrow to non-white space or `z` to narrow to a subword (e.g. excludes `_`) -[define.bind.edit_motion_match_obj] -merge = "{{bind.edit_motion}}" +[[define.bind]] +id = "edit_motion_match_obj" +default = "{{bind.edit_motion}}" command = "selection-utilities.moveBy" kind = "motion" args.selectWhole = true args.boundary = "start" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m" name = "match" description = """ @@ -1135,14 +1145,14 @@ kind = "motion" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m m" name = "smart expand" description = "Use VSCode's built-in smart expansion command" command = "editor.action.smartSelect.expand" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m w" name = "around subwrd →" description = "(camel/snake case)" @@ -1153,7 +1163,7 @@ args.unit = "subword" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m b" name = "around subwrd ←" description = "(camel/snake case)" @@ -1162,7 +1172,7 @@ args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+w" name = "ard word →" combinedName = "around word →/←" @@ -1171,7 +1181,7 @@ args.unit = "word" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+b" name = "ard word ←" combinedName = "around word →/←" @@ -1179,7 +1189,7 @@ args.unit = "word" args.value = "{{-count || -1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m e" name = "in subwrd" combinedName = "in → subword/word" @@ -1189,7 +1199,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+e" name = "in word" combinedName = "in → subword/word" @@ -1198,7 +1208,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m p" name = "in parag. →" combinedName = "in paragraph →/←" @@ -1208,7 +1218,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m o" name = "in parag. ←" combinedName = "in paragraph →/←" @@ -1217,7 +1227,7 @@ args.boundary = "both" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+p" name = "arn parag. →" combinedName = "around paragraph →/←" @@ -1226,7 +1236,7 @@ args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+o" name = "arn parag. ←" combinedName = "around paragraph →/←" @@ -1234,7 +1244,7 @@ args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m 0" name = "arn subsec →" combinedName = "around subsection →/←" @@ -1243,7 +1253,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+0" name = "arn subsec ←" combinedName = "around subsection →/←" @@ -1251,7 +1261,7 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m 9" name = "in subsec →" combinedName = "in subsection →/←" @@ -1260,7 +1270,7 @@ args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m shift+9" name = "in subsec ←" combinedName = "in subsection →/←" @@ -1268,14 +1278,14 @@ args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m g" name = "other..." description = "additional objects to match..." command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m g 0" name = "section →" combinedName = "section →/←" @@ -1284,7 +1294,7 @@ args.unit = "section" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m g 9" name = "section ←" combinedName = "section →/←" @@ -1292,7 +1302,7 @@ args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m g w" name = "around WORD →" combinedName = "around WORD →/←" @@ -1301,7 +1311,7 @@ args.unit = "BigWord" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m g b" name = "around WORD ←" combinedName = "around WORD →/←" @@ -1309,7 +1319,7 @@ args.unit = "BigWord" args.value = "{{-(count || 1)}}" [[bind]] -merge = "{{bind.edit_motion_match_obj}}" +default = "{{bind.edit_motion_match_obj}}" key = "m g e" name = "in WORD" args.unit = "BigWord" @@ -1317,7 +1327,7 @@ args.boundary = "both" args.value = "{{count || 1}}" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m [" name = "in parens" combinedName = "in/arnd parens" @@ -1333,7 +1343,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandWithinBrackets" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m shift+[" name = "arnd parens" combinedName = "in/arnd parens" @@ -1344,7 +1354,7 @@ will seek out larger and larger scopes command = "selection-utilities.expandAroundBrackets" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m '" name = "in quotes" description = """ @@ -1360,7 +1370,7 @@ will seek out larger and larger scopes command = "bracketeer.selectQuotesContent" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m shift+'" name = "around quotes" combinedName = "in/arnd quotes" @@ -1372,7 +1382,7 @@ command = "runCommands" args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesContent"] [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m shift+." name = "in <>" description = "text inside angle brackets" @@ -1382,7 +1392,7 @@ combinedDescription = "text inside angle brackets / pairs (e.g. text in text< command = "extension.selectAngleBrackets" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m shift+," name = "in ><" combinedName = "in <> / in ><" @@ -1390,7 +1400,7 @@ description = "text inside tag pairs (e.g. text)" command = "extension.selectInTag" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m i" name = "in indent" description = "all text at the same indentation level" @@ -1403,7 +1413,7 @@ below this (ala c-like syntax) command = "vscode-select-by-indent.select-inner" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m shift+i" name = "arnd indent" description = """ @@ -1414,7 +1424,7 @@ combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" key = "m g i" name = "indent+top" description = """ @@ -1424,14 +1434,14 @@ combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer-top-only" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "in cell" description = "select text within a cell (ala jupyter)" key = "m c" command = "jupyter.selectCell" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "between pair" combinedDescription = """ Select between pairs of the same N characters (t) or distinct sets of N @@ -1458,7 +1468,7 @@ args.str = "{{captured}}" args.inclusive = false [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "between two" description = """ Select between two different sets of N characters, where N is the count e.g. @@ -1483,13 +1493,14 @@ args.inclusive = false # These are the most common, basic actions available in Larkin that can be used # to edit text in relation to the current selection. -[define.bind.edit_action] +[[define.bind]] +id = "edit_action" kind = "action" mode = "normal" tags = ["action"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" #- TODO: add documentation to these basic editor keys key = "i" name = "insert" @@ -1499,7 +1510,7 @@ args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] mode = ["normal", "selectedit", "syminsert"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "a" name = "append" description = "insert after cursor" @@ -1512,7 +1523,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+i" name = "insert start" mode = ["normal", "selectedit", "syminsert"] @@ -1523,7 +1534,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+a" name = "insert end" mode = ["normal", "selectedit", "syminsert"] @@ -1534,7 +1545,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "c" name = "change" description = """ @@ -1546,14 +1557,14 @@ command = "runCommands" args.commands = ["deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "c" when = "!editorHasMultilineSelection && editorHasSelection" command = "runCommands" args.commands = ["deleteRight", "master-key.enterInsert"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "c" when = "!editorHasSelection && master-key.count <= 1" command = "runCommands" @@ -1565,19 +1576,19 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "c" when = "!editorHasSelection && master-key.count > 1" command = "runCommands" args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert", ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+c" name = "change to/back" description = """Without a count: change from current char to end of line. With a count: @@ -1593,20 +1604,20 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+c" mode = ["normal", "selectedit"] when = "master-key.count > 1" command = "runCommands" args.commands = [ - "{{selectLinesUp}}", + "{{command.selectLinesUp}}", "deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert", ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" args.commands = [ "selection-utilities.shrinkToActive", { command = "cursorMove", args = { to = "right", select = true, value = "{{count}}" } }, @@ -1618,14 +1629,14 @@ name = "delete char" command = "runCommands" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "r" name = "replace char" description = "replace the character under the cursor" command = "master-key.replaceChar" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "ctrl+i" name = "insert char" mode = ["normal", "selectedit"] @@ -1633,7 +1644,7 @@ description = "insert a character in front of the cursor" command = "master-key.insertChar" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "p" name = "paste after" description = "Paste clipboard after the cursor/selection" @@ -1649,7 +1660,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "p" name = "paste after" combinedName = "paste before/after/in" @@ -1658,7 +1669,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" mode = ["normal", "insert"] @@ -1668,7 +1679,7 @@ description = "Paste clipboard at location" command = "editor.action.clipboardPasteAction" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+p" name = "paste before" combinedName = "paste before/after" @@ -1682,7 +1693,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+p" combinedName = "paste before/after" when = "!editorHasSelection" @@ -1690,7 +1701,7 @@ command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "repeat action" description = """ Repeat the last action command. Actions usually modify the text of a document in one way or @@ -1714,28 +1725,28 @@ commandHistory[i].name == 'replay') command = "master-key.enterNormal" [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "undo" key = "u" command = "runCommands" args.commands = ["undo", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "redo" key = "shift+u" command = "runCommands" args.commands = ["redo", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'toggle check' description = "Toggle a markdown checkbox" key = "shift+6" command = "markdown-checkbox.markCheckbox" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "d" name = "delete" description = """ @@ -1745,13 +1756,13 @@ count, delete up to the next `count` lines and store to clipboard. when = "!editorHasSelection" command = "runCommands" args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "editor.action.clipboardCutAction", { command = "master-key.setMode", args = { value = "normal" } }, ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "d" when = "editorHasSelection" command = "runCommands" @@ -1761,7 +1772,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+d" mode = "normal" name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." @@ -1773,15 +1784,15 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+d" mode = "normal" when = "master-key.count > 1" command = "runCommands" -args.commands = ["{{selectLinesUp}}", "deleteRight"] +args.commands = ["{{command.selectLinesUp}}", "deleteRight"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "y" name = "copy" description = "copy selected text to clipboard" @@ -1789,18 +1800,18 @@ command = "runCommands" args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "y" when = "master-key.count > 1" command = "runCommands" args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive", ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+y" name = "copy (eol/up)" description = "without a count: copy to end of line; with a count: copy this and the previous N lines" @@ -1814,26 +1825,26 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+y" when = "master-key.count > 1" command = "runCommands" args.commands = [ - "{{selectLinesUp}}", + "{{command.selectLinesUp}}", "editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive", ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+." name = "indent" description = "Indent lines" command = "editor.action.indentLines" [[bind]] -args.commands = ["{{selectLinesDown}}", "editor.action.indentLines"] -merge = "{{bind.edit_action}}" +args.commands = ["{{command.selectLinesDown}}", "editor.action.indentLines"] +default = "{{bind.edit_action}}" key = "shift+." name = "indent" description = "Indent lines" @@ -1841,7 +1852,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+," name = "deindent" when = "master-key.count < 1" @@ -1850,19 +1861,20 @@ command = "editor.action.outdentLines" [[bind]] args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "editor.action.outdentLines", "selection-utilities.shrinkToActive", ] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "shift+," name = "deindent" when = "master-key.count >= 1" description = "Deindent lines" command = "runCommands" -[define.bind.edit_action_history] -merge = "{{bind.edit_action}}" +[[define.bind]] +id = "edit_action_history" +default = "{{bind.edit_action}}" tags = ["history"] # ## Number actions @@ -1870,14 +1882,14 @@ tags = ["history"] # These commands modify or enter numbers in some way. [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'inc #' description = "Increment a number by 1" key = "=" command = "selection-utilities.incrementNumber" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'dec #' description = "Decrement a number by 1 " key = "shift+=" @@ -1887,103 +1899,104 @@ command = "selection-utilities.decrementNumber" # These modify the capitalization of letters in some way. -[define.bind.edit_action_capitals] -merge = "{{bind.edit_action}}" +[[define.bind]] +id = "edit_action_capitals" +default = "{{bind.edit_action}}" mode = ["normal", "selectedit"] [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'camel' description = "Swap style to lower camel case (`camelCase`)" key = "` c" command = "extension.changeCase.camel" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'constant' description = "Swap style to constant (`IS_CONSTANT`)" key = "` shift+u" command = "extension.changeCase.constant" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'dot' description = "Swap style to dot case (`dot.case`)" key = "` ." command = "extension.changeCase.dot" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'kebab' description = "Swap style to kebab case (`kebab-case`)" key = "` -" command = "extension.changeCase.kebab" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'all lower' description = "Swap all to lower case" key = "` shift+l" command = "extension.changeCase.lower" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'first lower' description = "Swap first letter to lower case" key = "` l" command = "extension.changeCase.lowerFirst" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'spaces' description = "Swap to spaces (`camelCase` -> `camel case`)" key = "` space" command = "extension.changeCase.no" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'Camel' description = "Swap to upper camel case (`CamelCase`)" key = "` shift+c" command = "extension.changeCase.pascal" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'path' description = "Swap to 'path' case (`path/case`)" key = "` /" command = "extension.changeCase.path" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'snake' description = "Swap to snake case (`snake_case`)" key = "` shift+-" command = "extension.changeCase.snake" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'swap' description = "Swap upper and lower case letters" key = "` s" command = "extension.changeCase.swap" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'title' description = "Swap to title case (all words have first upper case letter)" key = "` t" command = "extension.changeCase.title" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'all upper' description = "Swap to use all upper case letters" key = "` shift+y" command = "extension.changeCase.upper" [[bind]] -merge = "{{bind.edit_action_capitals}}" +default = "{{bind.edit_action_capitals}}" name = 'first upper' description = "Swap first character to upper case" key = "` u" @@ -1994,14 +2007,14 @@ command = "extension.changeCase.upperFirst" # These keys are all organized under the `space` key and they "do" something. These are generally more elaborate editing operations in the current editor pane. [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "do" key = "space" description = "additional actions, mostly for modifying specific syntactic formats" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "paste after line" combinedName = "paste after/before line" combinedKey = "p/shift+p" @@ -2017,7 +2030,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" priority = 2 name = "paste before line" combinedName = "paste after/before line" @@ -2032,7 +2045,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" priority = 2 name = "add line below" combinedName = "add line below/above" @@ -2043,7 +2056,7 @@ key = "space o" command = "editor.action.insertLineAfter" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = "add line above" priority = 2 combinedName = "add line below/above" @@ -2052,7 +2065,7 @@ key = "space shift+o" command = "editor.action.insertLineBefore" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'sym insert' description = "Insert a character pair around a character" priority = 1 @@ -2073,14 +2086,14 @@ args.after = "{{var.braces[captured].after || captured}}" args.followCursor = true [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'trim white' description = "Delete all external whitespace (left and right edges)" key = "space shift+-" command = "selection-utilities.trimWhitespace" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space w" name = "wrap p" combinedName = "wrap/join lines" @@ -2090,7 +2103,7 @@ combinedKey = "w/j" command = "rewrap.rewrapComment" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'join' combinedName = "wrap/join lines" description = "Remove newline between current and next line" @@ -2098,10 +2111,10 @@ key = "space j" mode = ["normal", "selectedit"] when = "!editorHasSelection" command = "runCommands" -args.commands = ["{{selectLinesDown}}", 'editor.action.joinLines'] +args.commands = ["{{command.selectLinesDown}}", 'editor.action.joinLines'] [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" combinedName = "wrap/join lines" name = 'join' description = "Remove newline between current and next line" @@ -2110,7 +2123,7 @@ key = "space j" command = "editor.action.joinLines" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space f" name = "format" combinedName = "format / format document" @@ -2119,11 +2132,11 @@ command = "editor.action.formatSelection" [[bind]] args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "editor.action.formatSelection", "selection-utilities.shrinkToActive", ] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space f" combinedName = "format / format document" combinedKey = "f/shift+f" @@ -2134,64 +2147,64 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space shift+f" name = "format doc" combinedName = "format / format document" command = "editor.action.formatDocument" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'parens' description = "actions related to various brackets (`[`, `(`, `{`)" key = "space [" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'remove' description = "Removes surrounding pairs" key = "space [ d" command = "bracketeer.removeBrackets" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'parens/brackets' description = "Swap between `[`, `(` and `{`" key = "space [ s" command = "bracketeer.swapBrackets" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'quotes' description = "Actions related to quotes" key = "space '" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'remove' description = "Removes quotes (', \" or `)" key = "space ' d" command = "bracketeer.removeQuotes" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'swap' description = "Swap quotes (', \" or `)" key = "space ' s" command = "bracketeer.swapQuotes" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space /" combinedName = "(block) comment" when = "master-key.count < 1" command = "editor.action.commentLine" [[bind]] -args.commands = ["{{selectLinesDown}}", "editor.action.commentLine"] -merge = "{{bind.edit_action}}" +args.commands = ["{{command.selectLinesDown}}", "editor.action.commentLine"] +default = "{{bind.edit_action}}" key = "space /" name = "comment lines" combinedName = "(block) comment" @@ -2202,7 +2215,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space shift+/" when = "master-key.count < 1" combinedName = "(block) comment" @@ -2210,11 +2223,11 @@ command = "editor.action.blockComment" [[bind]] args.commands = [ - "{{selectLinesDown}}", + "{{command.selectLinesDown}}", "editor.action.blockComment", "selection-utilities.shrinkToActive", ] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space shift+/" name = "block comment lines" combinedName = "(block) comment" @@ -2223,7 +2236,7 @@ when = "master-key.count >= 1" command = "runCommands" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'inc all #' combinedName = "inc/dec all #" combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" @@ -2233,7 +2246,7 @@ key = "space =" command = "selection-utilities.incrementNumberPerSelection" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'dec all #' combinedName = "inc/dec all #" description = "Decrement selected numbers; decrement increases per selection" @@ -2241,14 +2254,14 @@ key = "space shift+=" command = "selection-utilities.decrementNumberPerSelection" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" name = 'nb cell' description = "Actions related to notebook cells" key = "space c" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space c i" when = "editorLangId == 'quarto'" command = "quarto.insertCodeCell" @@ -2256,13 +2269,13 @@ name = "insert cell" description = "insert a new cell in a notebook" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space c s" when = "editorLangId != 'quarto'" command = "jupyter.selectCell" [[bind]] -merge = "{{bind.edit_action}}" +default = "{{bind.edit_action}}" key = "space ." name = 'sent. lines' description = "Split paragraph into one line per sentence" @@ -2300,7 +2313,7 @@ command = "selection-utilities.cancelSelection" # These commands interact with the history of previously typed commands to repeat some sequence of commands. They can record any edits, and any commands that are issued through master key bindings. Commands that are not part of this binding file (e.g. a standard call to Cmd/Ctrl+V to paste) will not be recorded. You can copy your non-master-key bindings over to master key (so that they will be recorded) by [customizing your bindings](#customized-bindings) and using `Import Default Bindings` and `Import User Bindings` to allow all of the default and user bindings stored in VSCOde's normal keybinding files to be recorded by master key. (You will have to remove your original user bindings from the VSCOde `keybinding.json` file manually) [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "record" description = "Start/stop recording Master Key commands" key = "shift+q" @@ -2309,7 +2322,7 @@ command = "master-key.record" args.on = true [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "record" description = """ Start/stop recording key presses defined by Master Key pushing it to the @@ -2325,11 +2338,11 @@ args.on = false [[bind.args.commands]] command = "master-key.pushHistoryToStack" -args.whereComputedRangeIs.from = 'commandHistory[index-1].name === "record"' -args.whereComputedRangeIs.to = "index" +args.whereRangeIs.from = '{{commandHistory[index-1].name === "record"}}' +args.whereRangeIs.to = "{{index}}" [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "replay" description = """ Replay the Master Key command sequence at the top of the `history` stack. Specifying @@ -2340,7 +2353,7 @@ command = "master-key.replayFromStack" args.index = "{{count}}" [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "store macro" description = """ Stores the top of the `history` stack into a named register. Specifying a count stores the @@ -2353,7 +2366,7 @@ args.register = "macro" args.contents = "macro[macro.length-(count || 0)-1]" [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "replay stored" description = """ Replay a recorded Master Key command sequence from a named register, pushing @@ -2376,22 +2389,22 @@ command = "master-key.replayFromStack" args.index = 0 [[bind]] -merge = "{{bind.edit_action_history}}" +default = "{{bind.edit_action_history}}" name = "store last" description = """ Store the N most recently run commands as a macro, where N is the count (defaulting to 1). """ key = "q l" command = "master-key.pushHistoryToStack" -args.whereComputedRangeIs.from = "index-(count || 0)" -args.whereComputedRangeIs.to = "index" +args.whereRangeIs.from = "{{index-(count || 0)}}" +args.whereRangeIs.to = "{{index}}" # ## Utility Commands # These actions include miscellaneous utilities. [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" key = "shift+ctrl+;" name = "palette" finalKey = false @@ -2405,14 +2418,14 @@ show command suggestions within the context of the current mode and keybinding p command = "master-key.commandPalette" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "git..." description = "git commands" key = "tab g" command = "master-key.prefix" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "pull" combinedName = "push/pull" description = "pull changes from remote" @@ -2422,14 +2435,14 @@ key = "tab g p" command = "git.pull" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "push" description = "push changes to remote" key = "tab g shift+p" command = "git.push" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "checkout" combinedName = "commit/checkout" description = "commit changes" @@ -2439,7 +2452,7 @@ key = "tab g c" command = "git.commit" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "checkout" combinedName = "commit/checkout" description = "checkout changes" @@ -2447,21 +2460,21 @@ key = "tab g shift+c" command = "git.checkout" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g r" command = "git.revertSelectedRanges" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "revert range" description = "revert unstaged changes in selected range" key = "tab g s" command = "git.stageSelectedRanges" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "commands..." description = "show GitLens command palette for git" key = "tab g g" @@ -2471,25 +2484,26 @@ command = "gitlens.gitCommands" # These miscellaneous utility commands are all organized uner the prefix `tab`. -[define.bind.util] +[[define.bind]] +id = "util" when = "editorTextFocus && !findWidgetVisible" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "utility" key = "tab" description = "utility related commands: file opening, window manipulation, debugging etc..." command = "master-key.prefix" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "open recent" description = "Open recent file" key = "tab r" command = "workbench.action.openRecent" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "hover" description = "show the hover view" combinedName = "(debug) hover" @@ -2499,7 +2513,7 @@ key = "tab h" command = "editor.action.showHover" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "debug hover" combinedName = "(debug) hover" description = "show the debug hover view" @@ -2507,7 +2521,7 @@ key = "tab shift+h" command = "editor.debug.action.showDebugHover" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "add mark" combinedName = "add mark / mark..." description = "toggle bookmark at given line" @@ -2519,7 +2533,7 @@ combinedKey = "shift+m / m" command = "vsc-labeled-bookmarks.toggleBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "mark" combinedName = "add mark / mark..." description = "bookmark related commands" @@ -2527,39 +2541,39 @@ key = "tab m" command = "master-key.prefix" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "mark ↓" description = "move to next bookmark" combinedName = "mark ↓/↑" combinedDescription = "move to next/previous bookmark" combinedKey = "j/k" key = "tab m j" -when = "!master-key.var.select_on && !editorHasSelection" +when = "!master-key.var.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" combinedName = "mark ↓/↑" key = "tab m j" -when = "master-key.var.select_on || editorHasSelection" +when = "master-key.var.select || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" key = "tab m k" -when = "!master-key.var.select_on && !editorHasSelection" +when = "!master-key.var.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "mark ↑" combinedName = "mark ↓/↑" description = "move to previous bookmark" key = "tab m k" -when = "master-key.var.select_on || editorHasSelection" +when = "master-key.var.select || editorHasSelection" command = "runCommands" args.commands = [ "vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", @@ -2567,21 +2581,21 @@ args.commands = [ ] [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "remove mark" description = "remove bookmark (use quick selection)" key = "tab m d" command = "vsc-labeled-bookmarks.deleteBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "nav marks" description = "reveal quick selection to move to a bookmark" key = "tab m t" command = "vsc-labeled-bookmarks.navigateToBookmark" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "error →" combinedName = "error →/←" combinedDescription = "move to next/previous error" @@ -2593,7 +2607,7 @@ key = "tab e" command = "editor.action.marker.next" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "error ←" combinedName = "error →/←" description = """ @@ -2603,7 +2617,7 @@ key = "tab shift+e" command = "editor.action.marker.prev" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "diff →" combinedName = "diff →/←" combinedDescription = "move to and show next/previous diff" @@ -2615,7 +2629,7 @@ key = "tab c" command = "editor.action.dirtydiff.next" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "diff ←" combinedName = "diff →/←" description = """ @@ -2625,7 +2639,7 @@ key = "tab shift+c" command = "editor.action.dirtydiff.previous" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "change →" combinedName = "change →/←" combinedDescription = "move to next/previous file change" @@ -2637,7 +2651,7 @@ key = "tab d" command = "workbench.action.editor.nextChange" [[bind]] -merge = "{{bind.edit_motion}}" +default = "{{bind.edit_motion}}" name = "change ←" combinedName = "change →/←" description = """ @@ -2650,13 +2664,14 @@ command = "workbench.action.editor.previousChange" # These are commands that interact with VSCode's user-interface in some way, rather than editing or moving around in the editor pane. -[define.bind.window] +[[define.bind]] +id = "window" kind = "util" mode = "normal" when = "editorTextFocus && !findWidgetVisible" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "cntr win" description = "center window at primary cursor position" key = "tab l" @@ -2664,21 +2679,21 @@ command = "selection-utilities.revealActive" args.at = "center" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "window" description = "window/editor pane manipulation-related commands" key = "tab w" command = "master-key.prefix" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "vert/horz" key = "tab w r" description = "Toggle between horizontal and vertical layouts" command = "workbench.action.toggleEditorGroupLayout" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "next window" combinedName = "next/previous window" description = "move to next window" @@ -2688,7 +2703,7 @@ combinedKey = "]/[" command = "workbench.action.focusNextGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "prev window" combinedName = "next/previous window" description = "move to previous window" @@ -2696,7 +2711,7 @@ key = "tab [" command = "workbench.action.focusPreviousGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "move →" combinedName = "move →/←" combinedDescription = "move editor to window left/right" @@ -2706,7 +2721,7 @@ key = "tab w l" command = "workbench.action.moveEditorToRightGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "←" combinedName = "move →/←" description = "move editor to window to left" @@ -2714,7 +2729,7 @@ key = "tab w h" command = "workbench.action.moveEditorToLeftGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "↓" combinedName = "move ↓/↑" combinedDescription = "move editor to window above/below" @@ -2724,7 +2739,7 @@ key = "tab w j" command = "workbench.action.moveEditorToBelowGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "↑" combinedName = "move ↓/↑" description = "move editor to window above" @@ -2732,14 +2747,14 @@ key = "tab w k" command = "workbench.action.moveEditorToAboveGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "split editor..." description = "split editor to in a given direction" key = "tab w s" command = "master-key.prefix" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "move →" combinedName = "split →/←" combinedDescription = "move editor to window left/right" @@ -2749,7 +2764,7 @@ key = "tab w s l" command = "workbench.action.splitEditorRight" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "←" combinedName = "split →/←" description = "split editor to window to left" @@ -2757,7 +2772,7 @@ key = "tab w s h" command = "workbench.action.splitEditorLeft" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "↓" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2767,7 +2782,7 @@ key = "tab w s j" command = "workbench.action.splitEditorDown" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "↑" combinedName = "split ↓/↑" combinedDescription = "split editor to window above/below" @@ -2777,28 +2792,28 @@ key = "tab w s k" command = "workbench.action.splitEditorUp" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "close pane" description = "close the given group of editors" key = "tab w x" command = "workbench.action.closeEditorsInGroup" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "max" description = "minimize size of all other windows" key = "tab w shift+m" command = "workbench.action.minimizeOtherEditors" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "equal" description = "equalize size of all windows" key = "tab w =" command = "workbench.action.evenEditorWidths" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "curs. win top" description = "center window so that primary cursor is at the top" key = "tab k" @@ -2809,7 +2824,7 @@ command = "selection-utilities.revealActive" args.at = "top" [[bind]] -merge = "{{bind.window}}" +default = "{{bind.window}}" name = "curs. win bot" combinedName = "center window top/bottom" description = "center window so that primary cursor is at the bottom" @@ -2822,7 +2837,7 @@ args.at = "bottom" # Commands for interacting with VSCode's debugger UI. [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "breakpt." combinedName = "breakpt / debug..." combinedKey = "shift+b/b" @@ -2832,7 +2847,7 @@ key = "tab shift+b" command = "editor.debug.action.toggleBreakpoint" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "debug..." combinedName = "breakpt / debug..." description = "assorted debugging actions" @@ -2840,7 +2855,7 @@ key = "tab b" command = "master-key.prefix" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "cond. break" description = "conditional breakpoint" key = "tab b shift+c" @@ -2848,35 +2863,35 @@ command = "editor.debug.action.conditionalBreakpoint" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "start" description = "start debugging" key = "tab b r" command = "workbench.action.debug.start" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "continue" description = "continue debugging" key = "tab b c" command = "workbench.action.debug.continue" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "next" description = "debug: step over next line" key = "tab b j" command = "workbench.action.debug.stepOver" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "into" description = "debug: step into next line" key = "tab b i" command = "workbench.action.debug.stepInto" [[bind]] -merge = "{{bind.util}}" +default = "{{bind.util}}" name = "out" description = "debug: step out" key = "tab b o" @@ -2891,12 +2906,13 @@ command = "workbench.action.debug.stepOut" # - save a single selection to a list of selections to use for later and # then move the cursor to the next selection you wish to add -[define.bind.edit_select_edit] +[[define.bind]] +id = "edit_select_edit" mode = "selectedit" kind = "motion" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "select-edit" description = """ Enter a mode where you can edit and manipulate (possibly multiple) selections. @@ -2907,7 +2923,7 @@ args.value = "selectedit" mode = "normal" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" key = "shift+'" combinedName = "rm cursors" combinedKey = "shift/ctrl+'" @@ -2919,7 +2935,7 @@ args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal" mode = ["selectedit", "normal"] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" key = "ctrl+'" mode = ["insert", "selectedit", "normal"] name = "rm cursors" @@ -2929,14 +2945,14 @@ command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = 'normal' description = "return to normal mode" key = "'" command = "master-key.enterNormal" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "add →" combinedName = "add →/←" description = "add cursor at the next match to the primary cursor's text" @@ -2947,7 +2963,7 @@ repeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "add ←" combinedName = "add →/←" description = "add cursor at the previous match to the primary cursor's text" @@ -2956,7 +2972,7 @@ command = "selection-utilities.addPrev" repeat = '{{count}}' [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "skip →" combinedName = "skip →/←" description = "move primary cursor to the next match of the primary cursor's text" @@ -2967,7 +2983,7 @@ command = "selection-utilities.skipNext" repeat = "{{count}}" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "skip ←" combinedName = "skip →/←" description = "move primary cursor to the previous match of the primary cursor's text" @@ -2976,21 +2992,21 @@ command = "selection-utilities.skipPrev" repeat = '{{count}}' [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "align ←" description = "align selections left" key = "=" command = "selection-utilities.alignSelectionsLeft" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "align →" description = "align selections right" key = "shift+=" command = "selection-utilities.alignSelectionsRight" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "→ sel" combinedName = "→/← sel" description = """ @@ -3007,7 +3023,7 @@ command = "selection-utilities.movePrimaryRight" repeat = '{{count}}' [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "← sel" combinedName = "→/← sel" description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" @@ -3016,7 +3032,7 @@ command = "selection-utilities.movePrimaryLeft" repeat = '{{count}}' [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "insert ↑" combinedName = "insert ↑/↓" description = """ @@ -3029,7 +3045,7 @@ command = "editor.action.insertCursorAbove" repeat = "{{count}}" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "insert sel ↓" combinedName = "insert ↑/↓" description = """ @@ -3040,7 +3056,7 @@ command = "editor.action.insertCursorBelow" repeat = "{{count-1}}" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "del. primary" combinedName = "del. primary/others" description = "remove the primary selection" @@ -3053,14 +3069,14 @@ command = "selection-utilities.deletePrimary" repeat = "{{count-1}}" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = 'del. others' description = "delete all other cursors but the primary selection" key = "shift+d" command = "removeSecondaryCursors" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "save sel" description = """ save all selections to the default register. @@ -3075,7 +3091,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "load sel" description = """ load previously saved selections in the default register. @@ -3088,7 +3104,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "exchange sel" description = """ exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. @@ -3101,7 +3117,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "rem saved sel" description = """ remove the most recently saved selection from the list of saved selections @@ -3114,7 +3130,7 @@ args.commands = [ ] [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" key = "shift+enter" name = "split sel" description = """ @@ -3123,7 +3139,7 @@ split selection into multiple selections by new line charactesr command = "selection-utilities.splitByNewline" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "sel all" description = """ create a selection for every match of the current word (or selection) @@ -3132,7 +3148,7 @@ key = "shift+8" command = "editor.action.selectHighlights" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "character" description = "split by a given character" key = "s" @@ -3147,14 +3163,14 @@ command = "selection-utilities.splitBy" args.text = "{{captured}}" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "string" description = "split by a given string" key = "shift+s" command = "selection-utilities.splitBy" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "include" description = """ Include all selections that contain a given marker @@ -3163,7 +3179,7 @@ key = "f" command = "selection-utilities.includeBy" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "exclude" description = """ Exclude all selections that contain a given marker @@ -3172,49 +3188,49 @@ key = "shift+f" command = "selection-utilities.excludeBy" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "create" description = "create selections of given string scoped to the current selections" key = "/" command = "selection-utilities.createBy" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "regex" description = "operations by regex rather than string" key = "r" command = "master-key.prefix" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "split" description = "split by a given regular expression" key = "r shift+s" command = "selection-utilities.splitByRegex" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "create" description = "create selections of given regular expression scoped to the current selections" key = "r /" command = "selection-utilities.createByRegex" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "include" description = "Include all selections that contain a given regular expression" key = "r f" command = "selection-utilities.includeByRegex" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "exclude" description = "Exclude all selections that contain a given regular expression" key = "r shift+f" command = "selection-utilities.excludeByRegex" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3224,7 +3240,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{bind.edit_select_edit}}" +default = "{{bind.edit_select_edit}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3237,7 +3253,7 @@ command = "selection-utilities.activeAtStart" # As a general rule, the letter keys issue commands of various sorts, and the other keys can be used to enter text (since we rarley want to surround a selection with an `a` but might want to surround it with `*` or `/`. -[define.var.braces] +[[define.var]] "{".before = "{" "{".after = "}" @@ -3270,16 +3286,18 @@ args.before = "{{var.braces[captured].before || captured}}" args.after = "{{var.braces[captured].after || captured}}" args.followCursor = true -[define.bind.edit_action_symmetric] +[[define.bind]] +id = "edit_action_symmetric" kind = "action" mode = "syminsert" -[define.bind.edit_motion_symmetric] +[[define.bind]] +id = "edit_motion_symmetric" kind = "motion" mode = "syminsert" [[bind]] -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" name = "sym insert mode" priority = 1 description = """ @@ -3293,7 +3311,7 @@ command = "master-key.setMode" args.value = "syminsert" [[bind]] -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" name = "Normal" description = "Return to normal model" key = "enter" @@ -3301,8 +3319,8 @@ command = "master-key.setMode" mode = "syminsert" [[bind]] -merge = "{{bind.edit_action_symmetric}}" -foreach.key = ["{{key: [a-z]}}", "shift+{{key: [a-z]}}"] +default = "{{bind.edit_action_symmetric}}" +foreach.key = ["{{key(`[a-z]`)}}", "shift+{{key(`[a-z]`)}}"] name = "" description = "this key is ignored and has no associated command in syminsert mode" key = "{{key}}" @@ -3313,7 +3331,7 @@ hideInPalette = true [[bind]] name = "esc. char" -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" key = "\\" description = "Insert escaped character" command = "runCommands" @@ -3329,7 +3347,7 @@ args.after = "{{'\\\\' + (var.braces[captured].after || captured)}}" args.followCursor = true [[bind]] -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" name = "delete" key = "x" description = """ @@ -3342,7 +3360,7 @@ args.count = "{{count}}" args.followCursor = true [[bind]] -merge = "{{bind.edit_motion_symmetric}}" +default = "{{bind.edit_motion_symmetric}}" key = "l" name = "sel →" description = "shrink/grow selections in direction that's rightwards from cursor" @@ -3351,7 +3369,7 @@ args.dir = "forward" args.count = "{{count}}" [[bind]] -merge = "{{bind.edit_motion_symmetric}}" +default = "{{bind.edit_motion_symmetric}}" key = "h" name = "sel ←" description = "shrink/grow selections in direction that's leftwards from cursor" @@ -3360,7 +3378,7 @@ args.dir = "backward" args.count = "{{count}}" [[bind]] -merge = "{{bind.edit_motion_symmetric}}" +default = "{{bind.edit_motion_symmetric}}" key = "o" name = "active to front" combinedKey = "o/shift+o" @@ -3370,7 +3388,7 @@ description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] -merge = "{{bind.edit_motion_symmetric}}" +default = "{{bind.edit_motion_symmetric}}" name = "active to end" combinedName = "active to start/end" description = "move cursor to back of selection" @@ -3378,19 +3396,19 @@ key = "shift+o" command = "selection-utilities.activeAtStart" [[bind]] -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" name = "undo" key = "u" command = "undo" [[bind]] -merge = "{{bind.edit_action_symmetric}}" +default = "{{bind.edit_action_symmetric}}" name = "redo" key = "shift+u" command = "redo" [[bind]] -merge = "{{bind.edit_motion_symmetric}}" +default = "{{bind.edit_motion_symmetric}}" key = "v" name = "shrink selection" description = """ @@ -3399,6 +3417,6 @@ reduce all selections to length zero and return to normal mode command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "var.select_on", value = false } }, + { command = "master-key.setFlag", args = { name = "var.select", value = false } }, "master-key.enterNormal", ] diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 554ad05b..edf94777 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -13,9 +13,9 @@ dependencies = [ [[package]] name = "anstream" -version = "0.6.19" +version = "0.6.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933" +checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192" dependencies = [ "anstyle", "anstyle-parse", @@ -43,18 +43,18 @@ dependencies = [ [[package]] name = "anstyle-query" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9" +checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2" dependencies = [ "windows-sys", ] [[package]] name = "anstyle-wincon" -version = "3.0.9" +version = "3.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882" +checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a" dependencies = [ "anstyle", "once_cell_polyfill", @@ -171,9 +171,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.15.4" +version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" [[package]] name = "icu_collections" @@ -484,9 +484,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.95" +version = "1.0.97" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778" +checksum = "d61789d7719defeb74ea5fe81f2fdfdbd28a803847077cecce2ff14e1472f6f1" dependencies = [ "unicode-ident", ] @@ -546,9 +546,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" [[package]] name = "rustversion" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" [[package]] name = "ryu" @@ -589,9 +589,9 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.140" +version = "1.0.142" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373" +checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" dependencies = [ "itoa", "memchr", @@ -690,18 +690,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708" +checksum = "0b0949c3a6c842cbde3f1686d6eea5a010516deb7085f79db747562d4102f41e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" +checksum = "cc5b44b4ab9c2fdd0e0512e6bece8388e214c0749f5862b114cc5b7a25daf227" dependencies = [ "proc-macro2", "quote", @@ -729,9 +729,9 @@ dependencies = [ [[package]] name = "toml" -version = "0.9.2" +version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed0aee96c12fa71097902e0bb061a5e1ebd766a6636bb605ba401c45c1650eac" +checksum = "75129e1dc5000bfbaa9fee9d1b21f974f9fbad9daec557a521ee6e080825f6e8" dependencies = [ "indexmap", "serde", @@ -753,9 +753,9 @@ dependencies = [ [[package]] name = "toml_parser" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97200572db069e74c512a14117b296ba0a80a30123fbbb5aa1f4a348f639ca30" +checksum = "b551886f449aa90d4fe2bdaa9f4a2577ad2dde302c61ecf262d80b116db95c10" dependencies = [ "winnow", ] @@ -959,21 +959,28 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" +[[package]] +name = "windows-link" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a" + [[package]] name = "windows-sys" -version = "0.59.0" +version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" dependencies = [ "windows-targets", ] [[package]] name = "windows-targets" -version = "0.52.6" +version = "0.53.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91" dependencies = [ + "windows-link", "windows_aarch64_gnullvm", "windows_aarch64_msvc", "windows_i686_gnu", @@ -986,57 +993,57 @@ dependencies = [ [[package]] name = "windows_aarch64_gnullvm" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" +checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764" [[package]] name = "windows_aarch64_msvc" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" +checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c" [[package]] name = "windows_i686_gnu" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" +checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3" [[package]] name = "windows_i686_gnullvm" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" +checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11" [[package]] name = "windows_i686_msvc" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" +checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d" [[package]] name = "windows_x86_64_gnu" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" +checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba" [[package]] name = "windows_x86_64_gnullvm" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" +checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57" [[package]] name = "windows_x86_64_msvc" -version = "0.52.6" +version = "0.53.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486" [[package]] name = "winnow" -version = "0.7.11" +version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd" +checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95" [[package]] name = "writeable" @@ -1102,9 +1109,9 @@ dependencies = [ [[package]] name = "zerovec" -version = "0.11.2" +version = "0.11.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428" +checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" dependencies = [ "yoke", "zerofrom", diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 30c82560..86217969 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -14,7 +14,7 @@ serde-wasm-bindgen = "0.6.5" string-offsets = { version = "0.2.0", features = ["wasm"] } test-log = "0.2.18" thiserror = "2.0.12" -toml = "0.9.2" +toml = { version = "0.9.2", features = ["preserve_order"] } validator = { version = "0.20.0", features = ["derive"] } wasm-bindgen = "0.2.100" diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 81b0dc83..3cbe1dde 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -7,7 +7,9 @@ mod validation; use crate::bind::foreach::expand_keys; use crate::bind::validation::{JsonObjectShape, valid_json_array_object, valid_key_binding}; -use crate::error::{Context, ErrorContext, Result, constrain, unexpected}; +use crate::error::{ + Context, ErrorContext, ErrorContexts, Result, ResultVec, constrain, reserved, unexpected, +}; use crate::util::{Merging, Plural, Required, Requiring, Resolving}; use crate::variable; use crate::variable::VariableExpanding; @@ -21,12 +23,6 @@ use validator::Validate; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; -#[wasm_bindgen] -pub fn debug_parse_command(command_str: &str) -> std::result::Result { - let result = toml::from_str::(command_str)?; - return Ok(Binding::new(result)?); -} - pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; fn default_mode() -> Spanned> { @@ -61,8 +57,10 @@ fn span_plural_default() -> Spanned> { * a `*`. * */ -#[derive(Deserialize, Validate, Clone, Debug)] +#[derive(Serialize, Deserialize, Validate, Clone, Debug)] pub struct BindingInput { + // should only be `Some` in context of `Define(Input)` + pub(crate) id: Option>, /** * @forBindingField bind * @@ -247,12 +245,40 @@ pub struct BindingInput { pub kind: Option>, } +impl BindingInput { + pub(crate) fn without_id(&self) -> Self { + return BindingInput { + id: None, + command: self.command.clone(), + args: self.args.clone(), + key: self.key.clone(), + when: self.when.clone(), + mode: self.mode.clone(), + priority: self.priority.clone(), + defaults: self.defaults.clone(), + foreach: self.foreach.clone(), + prefixes: self.prefixes.clone(), + finalKey: self.finalKey.clone(), + repeat: self.repeat.clone(), + name: self.name.clone(), + description: self.description.clone(), + hideInPalette: self.hideInPalette.clone(), + hideInDocs: self.hideInDocs.clone(), + combinedName: self.combinedName.clone(), + combinedKey: self.combinedKey.clone(), + combinedDescription: self.combinedDescription.clone(), + kind: self.kind.clone(), + }; + } +} + impl Merging for BindingInput { fn coalesce(self, new: Self) -> Self { return new; } fn merge(self, y: Self) -> Self { BindingInput { + id: y.id, command: self.command.coalesce(y.command), args: self.args.merge(y.args), key: self.key.coalesce(y.key), @@ -276,12 +302,42 @@ impl Merging for BindingInput { } } -#[derive(Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug)] pub struct CommandInput { + // should only be `Some` in context of `Define(Input)` + pub(crate) id: Option>, pub command: Spanned>, pub args: Option>, } +impl VariableExpanding for CommandInput { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + self.command + .expand_with_getter(getter.clone()) + .context_str("`command` field") + .context_range(&self.command)?; + self.args + .expand_with_getter(getter.clone()) + .context_str("`args` field") + .context_range(&self.args)?; + return Ok(()); + } +} + +impl CommandInput { + pub(crate) fn without_id(&self) -> Self { + return CommandInput { + id: None, + command: self.command.clone(), + args: self.args.clone(), + }; + } +} + #[wasm_bindgen(getter_with_clone)] #[derive(Clone, Debug, Serialize)] pub struct Command { @@ -300,6 +356,9 @@ impl Command { impl Command { pub fn new(input: CommandInput) -> Result { + if let Some(_) = input.id { + return reserved("id"); + } return Ok(Command { command: input.command.into_inner().resolve("`command` field")?, args: match input.args { @@ -346,7 +405,7 @@ impl BindingInput { return false; } - fn expand_foreach(&mut self) -> Result> { + fn expand_foreach(&mut self) -> ResultVec> { let mut result = vec![self.clone()]; while self.has_foreach() { result = self.expand_foreach_once(&result)?; @@ -354,7 +413,7 @@ impl BindingInput { return Ok(result); } - fn expand_foreach_once(&mut self, inputs: &Vec) -> Result> { + fn expand_foreach_once(&mut self, inputs: &Vec) -> ResultVec> { let foreach = match &self.foreach { Some(foreach) => foreach.get_ref(), None => &toml::map::Map::new(), @@ -384,7 +443,7 @@ impl BindingInput { } return Ok(result); } else { - return unexpected("`foreach` was not an object of arrays"); + return unexpected("`foreach` was not an object of arrays")?; } } else { return Ok(vec![]); @@ -393,77 +452,81 @@ impl BindingInput { } impl VariableExpanding for BindingInput { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { self.command - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`command` field") .context_range(&self.command)?; self.args - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`args` field") .context_range(&self.args)?; self.key - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`key` field") .context_range(&self.key)?; self.when - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`when` field") .context_range(&self.when)?; self.mode - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`mode` field") .context_range(&self.mode)?; self.priority - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`priority` field") .context_range(&self.priority)?; self.defaults - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`defaults` field") .context_range(&self.defaults)?; self.prefixes - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`prefixes` field") .context_range(&self.prefixes)?; self.finalKey - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`finalKey` field") .context_range(&self.finalKey)?; self.repeat - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`repeat` field") .context_range(&self.repeat)?; self.name - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`name` field") .context_range(&self.name)?; self.description - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`description` field") .context_range(&self.description)?; self.hideInPalette - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`hideInPalette` field") .context_range(&self.hideInPalette)?; self.hideInDocs - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`hideInDocs` field") .context_range(&self.hideInDocs)?; self.combinedName - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`combinedName` field") .context_range(&self.combinedName)?; self.combinedKey - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`combinedKey` field") .context_range(&self.combinedKey)?; self.combinedDescription - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`combinedDescription` field") .context_range(&self.combinedDescription)?; self.kind - .expand_value(var, value) + .expand_with_getter(getter.clone()) .context_str("`kind` field") .context_range(&self.kind)?; return Ok(()); @@ -471,7 +534,6 @@ impl VariableExpanding for BindingInput { } fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec)> { - let command_pos = input.command.span(); let command = input.command.get_ref().clone().resolve("`command` field")?; let args = input.args.clone(); if command == "runCommands" { @@ -535,11 +597,16 @@ fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec Result { + if let Some(_) = input.id { + return reserved("id"); + } + serde_wasm_bindgen::Serializer::json_compatible(); if let Some(_) = input.foreach { return unexpected("`foreach` with unresolved variables"); } let (input, commands) = regularize_commands(input)?; + // TODO this is where we should validate that prefix has `finalKey == false` return Ok(Binding { diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index ad8d0e9d..d2917cc4 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -202,7 +202,7 @@ const ALL_KEYS: [&'static str; 192] = [ ]; lazy_static! { - static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"\{\{key:\s*(.*)\}\}").unwrap(); + static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"\{\{\s*key\(\s*`(.*)`\s*\)\s*\}\}").unwrap(); } pub fn expand_keys(items: &Vec) -> Result> { diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 36ba3149..56b89e3f 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,76 +1,46 @@ use std::collections::HashMap; use crate::bind::{Binding, BindingInput, Command, CommandInput}; -use crate::error::{Context, ErrorContext, ErrorWithContext, Result, unexpected}; +use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; use crate::util::Requiring; +use crate::variable::VariableExpanding; #[allow(unused_imports)] use log::info; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; -use toml::{Spanned, Value}; +use toml::Spanned; use validator::Validate; use wasm_bindgen::prelude::*; #[derive(Deserialize, Clone, Debug, Validate)] pub struct DefineInput { - pub bind: Option>>, - pub command: Option>>, - pub var: Option, + pub var: Option>>>, + pub command: Option>>, + pub bind: Option>>, +} + +// TODO: resolve variables for each item in `DefineInput` until +// there are no variables left to resolve or we hit a limit +// NOTE: we might have to implement pruning to get this to +// run in a reasonable time + +pub trait VariableResolver { + fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()>; } #[wasm_bindgen] #[derive(Clone, Debug, Default)] pub struct Define { #[wasm_bindgen(skip)] - pub bind: Option>, + pub bind: HashMap, #[wasm_bindgen(skip)] - pub command: Option>, + pub command: HashMap, #[wasm_bindgen(skip)] - pub var: Option, -} - -#[wasm_bindgen] -impl Define { - pub fn bind(&self, key: &str) -> Result { - let value = self - .bind - .as_ref() - .require(format!("`{key}` field"))? - .get(key) - .require(format!("`{key}` field"))?; - return Ok(value.clone()); - } - - pub fn command(&self, key: &str) -> Result { - let value = self - .command - .as_ref() - .require(format!("`{key}` field"))? - .get(key) - .require(format!("`{key}` field"))?; - return Ok(value.clone()); - } - - pub fn var(&self, key: &str) -> Result { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - let value = self - .var - .as_ref() - .require(format!("`{key}` field"))? - .get(key) - .require(format!("`{key}` field"))?; - return match value.serialize(&to_json) { - Ok(result) => Ok(result), - Err(_) => unexpected("unexpected serialization error"), - }; - } + pub var: HashMap, } -fn map_with_err( - x: HashMap>, - f: &mut F, -) -> std::result::Result, Vec> +fn map_with_err(x: HashMap>, f: &mut F) -> ResultVec> where F: FnMut(T) -> Result, { @@ -79,7 +49,7 @@ where .into_iter() .filter_map(|(k, v)| { let span = v.span(); - let result = f(v.into_inner()).context(Context::Range(span)); + let result = f(v.into_inner()).context_range(&span); return result.map_err(|e| errors.push(e)).ok().map(|v| (k, v)); }) .collect(); @@ -91,24 +61,179 @@ where } impl Define { - pub fn new(input: DefineInput) -> std::result::Result> { - let bind = match input.bind { - Some(x) => Some(map_with_err(x, &mut |b| Binding::new(b))?), - None => None, - }; - let command = match input.command { - Some(x) => Some(map_with_err(x, &mut |c| Command::new(c))?), - None => None, - }; + pub fn new(input: DefineInput) -> ResultVec { + // STEP 1: resolve all definitions so that there are no interpolations of + // `var.`, `bind.` or `command.` variables + let mut resolved_bind = HashMap::>::new(); + let mut resolved_command = HashMap::>::new(); + let mut resolved_var = HashMap::::new(); + + // TODO: we don't want to parse expressions that start with a reference + // to a var. command. or bind. variable to be read as a variable reference here + // (also a good thing to writ ea test for down below) + + // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they + // must only reference previously defined variables (we've included the TOML feature + // to preserve order, so variables can reference other variables defined within the + // same block) + for def_block in input.var.into_iter().flatten() { + for (var, mut value) in def_block.into_iter() { + value.expand_with_getter(|id| { + if let Some((prefix, name)) = id.split_once('.') { + if prefix == "var" { + let resolved = resolved_var.get(name). + ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; + return Ok(Some(resolved.clone())); + } else if prefix == "bind" || prefix == "command" { + return Err(Error::ForwardReference(format!( + "`{id}`; you cannot refer to `{prefix}` values within `var` definitions" + )))?; + } + } + // TODO: refactor so that we use a unique enum type instead of + // Some/None to signal resolution + + // other types of variables are left unresolved + return Ok(None); + })?; + resolved_var.insert(var.clone(), value.get_ref().clone()); + } + } + + // STEP 1b: resolve [[define.command]] blocks + for mut def in input.command.into_iter().flatten() { + def.get_mut().expand_with_getter(|id| { + if let Some((prefix, name)) = id.split_once('.') { + if prefix == "var" { + let value = resolved_var + .get(name) + .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; + return Ok(Some(value.clone())); + } else if prefix == "command" { + let val = resolved_command.get(id).ok_or_else(|| { + Error::UndefinedVariable(format!("`{id}`")) + })?; + return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)) + } else if prefix == "bind" { + return Err(Error::ForwardReference(format!( + "`{id}`; you cannot refer to `{prefix}` values within `command` definitions" + )))?; + } + } + return Ok(None); + })?; + let id = def.get_ref().id.clone(); + resolved_command.insert( + id.require("id") + .context_range(&def.span())? + .get_ref() + .clone(), + def, + ); + } + + // STEP 1c: resolve [[define.bind]] blocks + for mut def in input.bind.into_iter().flatten() { + def.get_mut().expand_with_getter(|id| { + if let Some((prefix, name)) = id.split_once('.') { + if prefix == "var" { + let value = resolved_var + .get(name) + .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; + return Ok(Some(value.clone())); + } else if prefix == "command" { + let val = resolved_command + .get(name) + .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; + return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); + } else if prefix == "bind" { + let val = resolved_bind + .get(name) + .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; + return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); + } + } + return Ok(None); + })?; + let id = def.get_ref().id.clone(); + resolved_bind.insert( + id.require("id") + .context_range(&def.span())? + .get_ref() + .clone(), + def, + ); + } + + // STEP 2: cleanup results for use in `Define` struct + + // TODO: because resolution to the Binding and Command structs does not occur until + // later, we could, in theory end up with a *lot* of errors for the same lines, it + // will be important to clean up the output to only show one of these errors and + // remove the other instances; or convince our selves no such issue will arise + let bind = resolved_bind + .into_iter() + .map(|(k, v)| (k, v.into_inner().without_id())) + .collect(); + let command = map_with_err(resolved_command, &mut |c| Command::new(c.without_id()))?; return Ok(Define { bind, command, - var: input.var, + var: resolved_var, }); } } +// NOTE: why don't we provide public access to `bind` and `command`: this avoids +// extra implementation work, when the main use case for these two categories of +// definitions is to make the binding file more concise; `var.` values on +// the other hand are often used at runtime +#[wasm_bindgen] +impl Define { + pub fn var(&self, key: &str) -> Result { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let value = self.var.get(key).require(format!("`{key}` field"))?; + return match value.serialize(&to_json) { + Ok(result) => Ok(result), + Err(_) => unexpected("unexpected serialization error"), + }; + } +} + +impl VariableResolver for Define { + fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()> { + x.expand_with_getter(|var| { + if let Some((prefix, name)) = var.split_once('.') { + if prefix == "var" { + return Ok(Some( + self.var + .get(name) + .ok_or_else(|| Error::UndefinedVariable(var.into()))? + .clone(), + )); + } else if prefix == "command" { + let val = self + .command + .get(name) + .ok_or_else(|| Error::UndefinedVariable(var.into()))? + .clone(); + return Ok(Some(toml::Value::try_from(val)?)); + } else if prefix == "bind" { + let val = self + .bind + .get(name) + .ok_or_else(|| Error::UndefinedVariable(var.into()))? + .clone(); + return Ok(Some(toml::Value::try_from(val)?)); + } + } + return Ok(None); + })?; + return Ok(()); + } +} + mod tests { use test_log::test; @@ -116,105 +241,98 @@ mod tests { #[test] fn complete_parsing() { let data = r#" - var.y = "bill" + [[var]] + y = "bill" - [bind.foo] + [[bind]] + id = "foo" key = "x" command = "foo" args = { k = 1, h = 2 } - [command.foobar] + [[command]] + id = "foobar" command = "runCommands" args.commands = ["foo", "bar"] - [var.x] + [[var]] joe = "bob" + "#; - let result = toml::from_str::(data).unwrap(); - assert_eq!( - result - .var - .as_ref() - .unwrap() - .get("y") - .unwrap() - .as_str() - .unwrap(), - "bill" - ); + let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - assert_eq!( - result - .var - .as_ref() - .unwrap() - .get("x") - .unwrap() - .as_table() - .unwrap() - .get("joe") - .unwrap() - .as_str() - .unwrap(), - "bob" - ); - - let ref foo = result.bind.as_ref().unwrap().get("foo").unwrap().as_ref(); - assert_eq!(foo.key.as_ref().as_ref().unwrap(), "x"); - assert_eq!(foo.command.as_ref().as_ref().unwrap(), "foo"); + assert_eq!(result.var.get("y").unwrap().as_str().unwrap(), "bill"); + assert_eq!(result.var.get("joe").unwrap().as_str().unwrap(), "bob"); + let foo = result.bind.get("foo").unwrap(); + assert_eq!(foo.key.get_ref().as_ref().unwrap().as_str(), "x"); assert_eq!( foo.args .as_ref() .unwrap() - .as_ref() + .get_ref() .get("k") .unwrap() .as_integer() .unwrap(), 1 - ); - assert_eq!( - foo.args - .as_ref() - .unwrap() - .as_ref() - .get("h") - .unwrap() - .as_integer() - .unwrap(), - 2 - ); - - let foobar = result - .command - .as_ref() - .unwrap() - .get("foobar") - .unwrap() - .as_ref(); - assert_eq!(foobar.command.as_ref().as_ref().unwrap(), "runCommands"); - let commands = foobar - .args - .as_ref() - .unwrap() - .as_ref() - .get("commands") - .unwrap(); - let command_list = commands.as_array().unwrap(); - assert_eq!(command_list[0].as_str().unwrap(), "foo"); - assert_eq!(command_list[1].as_str().unwrap(), "bar"); - - let define = Define::new(result); - let foo_out = define - .as_ref() - .unwrap() - .bind - .as_ref() - .unwrap() - .get("foo") - .unwrap(); - assert_eq!(foo_out.commands[0].command, "foo"); + ) + + // let ref foo = result.bind.as_ref().unwrap().get("foo").unwrap().as_ref(); + // assert_eq!(foo.key.as_ref().as_ref().unwrap(), "x"); + // assert_eq!(foo.command.as_ref().as_ref().unwrap(), "foo"); + // assert_eq!( + // foo.args + // .as_ref() + // .unwrap() + // .as_ref() + // .get("k") + // .unwrap() + // .as_integer() + // .unwrap(), + // 1 + // ); + // assert_eq!( + // foo.args + // .as_ref() + // .unwrap() + // .as_ref() + // .get("h") + // .unwrap() + // .as_integer() + // .unwrap(), + // 2 + // ); + + // let foobar = result + // .command + // .as_ref() + // .unwrap() + // .get("foobar") + // .unwrap() + // .as_ref(); + // assert_eq!(foobar.command.as_ref().as_ref().unwrap(), "runCommands"); + // let commands = foobar + // .args + // .as_ref() + // .unwrap() + // .as_ref() + // .get("commands") + // .unwrap(); + // let command_list = commands.as_array().unwrap(); + // assert_eq!(command_list[0].as_str().unwrap(), "foo"); + // assert_eq!(command_list[1].as_str().unwrap(), "bar"); + + // let define = Define::new(result); + // let foo_out = define + // .as_ref() + // .unwrap() + // .bind + // .as_ref() + // .unwrap() + // .get("foo") + // .unwrap(); + // assert_eq!(foo_out.commands[0].command, "foo"); } } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 852daa41..cc8a8a9f 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -25,6 +25,12 @@ pub enum Error { Unexpected(&'static str), #[error("unresolved {0}")] Unresolved(String), + #[error("undefined variable {0}")] + UndefinedVariable(String), + #[error("forward reference to {0}")] + ForwardReference(String), + #[error("reserved field name {0}")] + ReservedField(&'static str), #[error("parsing regex failed with {0}")] Regex(#[from] regex::Error), } @@ -35,8 +41,10 @@ pub enum Error { #[derive(Debug, Error, Clone)] pub struct ErrorWithContext { #[source] - error: Error, - contexts: Vec, + #[wasm_bindgen(skip)] + pub error: Error, + #[wasm_bindgen(skip)] + pub contexts: Vec, } fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { @@ -51,6 +59,12 @@ impl From for Vec { } } +impl From for Vec { + fn from(value: Error) -> Self { + return vec![value.into()]; + } +} + #[wasm_bindgen] impl ErrorWithContext { pub fn report(&self, content: &str) -> ErrorReport { @@ -148,6 +162,10 @@ pub fn unexpected(msg: &'static str) -> Result { return Err(Error::Unexpected(msg))?; } +pub fn reserved(msg: &'static str) -> Result { + return Err(Error::ReservedField(msg))?; +} + pub trait ErrorContext where Self: Sized, @@ -214,4 +232,36 @@ impl ErrorContext for Result { } } +pub trait ErrorContexts +where + T: Sized, + Self: Sized, +{ + fn context(self, context: Context) -> ResultVec; + fn context_str(self, context: impl Into) -> ResultVec { + self.context(Context::String(context.into())) + } + fn context_range(self, context: &impl Spannable) -> ResultVec { + if let Some(range) = context.range() { + return self.context(Context::Range(range)); + } else { + return self.context(Context::Range(UNKNOWN_RANGE)); + } + } +} + +impl ErrorContexts for ResultVec { + fn context(self, context: Context) -> ResultVec { + return match self { + Ok(x) => Ok(x), + Err(mut errs) => { + errs.iter_mut() + .for_each(|e| e.contexts.push(context.clone())); + Err(errs) + } + }; + } +} + pub type Result = std::result::Result; +pub type ResultVec = std::result::Result>; diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index c992911f..27697e3f 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,8 +1,8 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; -use crate::define::{Define, DefineInput}; -use crate::error::{Context, Error, ErrorContext, ErrorReport, ErrorWithContext, Result}; -use crate::file; +use crate::define::{Define, DefineInput, VariableResolver}; +use crate::error::{ErrorContext, ErrorReport, ResultVec}; +use crate::variable::VariableExpanding; use log::info; use serde::{Deserialize, Serialize}; @@ -25,23 +25,8 @@ pub struct KeyFile { } impl KeyFile { - fn new(input: KeyFileInput) -> std::result::Result> { + fn new(mut input: KeyFileInput) -> ResultVec { let mut errors = Vec::new(); - let bind = input - .bind - .map(|bind| { - return bind - .into_iter() - .filter_map(|b| { - let span = b.span(); - Binding::new(b.into_inner()) - .context_range(&span) - .map_err(|e| errors.push(e)) - .ok() - }) - .collect(); - }) - .unwrap_or_default(); let define = input .define @@ -56,6 +41,25 @@ impl KeyFile { }) .flatten() .unwrap_or_default(); + + // TODO: expand each define using the other known definitions + // (with some limit on the number of iterations to resolved) + define.resolve_variables(&mut input.bind)?; + + let bind = input + .bind + .map(|bindings| { + return bindings + .into_iter() + .filter_map(|b| { + let span = b.span(); + let result = Binding::new(b.into_inner()).context_range(&span); + result.map_err(|e| errors.push(e)).ok() + }) + .collect(); + }) + .unwrap_or_default(); + if errors.len() == 0 { return Ok(KeyFile { bind, define }); } else { @@ -84,7 +88,7 @@ pub fn parse_string(file_content: &str) -> KeyFileResult { }; } -fn parse_string_helper(file_content: &str) -> std::result::Result> { +fn parse_string_helper(file_content: &str) -> ResultVec { let parsed = toml::from_str::(file_content); return match parsed { Ok(input) => KeyFile::new(input), @@ -122,17 +126,17 @@ mod tests { assert_eq!(items.bind[1].key, "h"); assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); - assert_eq!( - items - .define - .var - .as_ref() - .unwrap() - .get("foo") - .unwrap() - .as_str() - .unwrap(), - "bar" - ) + // assert_eq!( + // items + // .define + // .var + // .as_ref() + // .unwrap() + // .get("foo") + // .unwrap() + // .as_str() + // .unwrap(), + // "bar" + // ) } } diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 9a5a6a4a..56bc6eb3 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -114,7 +114,7 @@ impl Requiring for Option { // required values are only required at the very end of parsing, once all known defaults // have been resolved -#[derive(Default, Deserialize, Serialize, PartialEq, Debug, Clone)] +#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged)] pub enum Required { #[default] @@ -172,7 +172,7 @@ impl Required { } } -#[derive(Default, Deserialize, PartialEq, Debug, Clone)] +#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged)] pub enum Plural { #[default] diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index 8eb93876..55d4d8c9 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -1,4 +1,4 @@ -use crate::error::{Error, Result}; +use crate::error::{Error, ErrorContexts, ErrorWithContext, Result, ResultVec}; use crate::util::{Merging, Plural, Required, Resolving}; #[allow(unused_imports)] @@ -8,74 +8,147 @@ use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; use toml::Spanned; -use validator::{Validate, ValidationError}; pub trait VariableExpanding { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()>; + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone; + fn expand_value(&mut self, var: &str, value: &toml::Value) -> ResultVec<()> { + self.expand_with_getter(|e_var| { + if e_var == var { + Ok(Some(value.clone())) + } else { + Ok(None) + } + }) + } } impl VariableExpanding for Spanned { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { - self.get_mut().expand_value(var, value)?; - Ok(()) + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + return self + .get_mut() + .expand_with_getter(getter) + .context_range(&self.span()); + } +} + +impl VariableExpanding for Vec { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + return flatten_errors( + self.iter_mut() + .map(|x| x.expand_with_getter(getter.clone())), + ); + } +} + +fn flatten_errors(errs: impl Iterator>) -> ResultVec<()> { + let errors = errs.filter(|x| x.is_err()); + let flat_errs = errors + .into_iter() + .flat_map(|x| x.unwrap_err().into_iter()) + .collect::>(); + + if flat_errs.len() > 0 { + return Err(flat_errs); + } else { + return Ok(()); } } impl VariableExpanding for Plural { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { match self { - Plural::Zero => (), - Plural::One(x) => x.expand_value(var, value)?, - Plural::Many(items) => items - .iter_mut() - .map(|v| v.expand_value(var, value)) - .collect::>()?, + Plural::Zero => return Ok(()), + Plural::One(x) => return x.expand_with_getter(getter), + Plural::Many(items) => { + return flatten_errors( + items + .iter_mut() + .map(|v| v.expand_with_getter(getter.clone())), + ); + } } - return Ok(()); } } impl VariableExpanding for Required { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { - return match self { - Required::DefaultValue => Ok(()), - Required::Value(x) => x.expand_value(var, value), - }; + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + Ok(match self { + Required::DefaultValue => (), + Required::Value(x) => x.expand_with_getter(getter)?, + }) } } impl VariableExpanding for toml::map::Map { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { - return self - .iter_mut() - .map(|(_, v)| v.expand_value(var, value)) - .collect::>(); + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + return flatten_errors( + self.iter_mut() + .map(|(_, v)| v.expand_with_getter(getter.clone())), + ); } } impl VariableExpanding for toml::Value { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + // TODO: this is one place where we would want to implement pruning + // when computing multiple passes of variable expansion + // we'd need some structure to keep track of where we are in the + // tree and mark certain branches as dead if they return `Ok(false)` + // or any `Err`. + // we could do this with a mutable hash map that maps given + // items to their last return state match self { - toml::Value::String(str) => str.expand_value(var, value)?, - toml::Value::Array(items) => items - .iter_mut() - .map(|i| i.expand_value(var, value)) - .collect::>()?, - toml::Value::Table(kv) => kv.expand_value(var, value)?, - _ => (), + toml::Value::String(str) => return str.expand_with_getter(getter), + toml::Value::Array(items) => { + return flatten_errors( + items + .iter_mut() + .map(|i| i.expand_with_getter(getter.clone())), + ); + } + toml::Value::Table(kv) => return kv.expand_with_getter(getter.clone()), + _ => return Ok(()), } - - return Ok(()); } } impl VariableExpanding for Option { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { - match self { - Some(v) => v.expand_value(var, value)?, + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + Ok(match self { + Some(v) => v.expand_with_getter(getter)?, None => (), - }; - return Ok(()); + }) } } @@ -116,60 +189,62 @@ where } } -#[derive(Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug)] #[serde(transparent)] pub struct Value(ValueEnum) where - toml::Value: As, - T: Copy; + toml::Value: As; -#[derive(Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug)] #[serde(untagged)] enum ValueEnum where toml::Value: As, - T: Copy, { Literal(T), Variable(String), } lazy_static! { - static ref VAR_STRING: Regex = Regex::new(r"^\{\{(.*)\}\}$").unwrap(); + static ref VAR_STRING: Regex = Regex::new(r"^\{\{(.+)\}\}$").unwrap(); } fn variable_name(x: &str) -> Result<&str> { - let captures = VAR_STRING + return Ok(VAR_STRING .captures(x) - .ok_or_else(|| Error::Constraint(r"string surrounded by `{{` and `}}`".into()))?; - return Ok(captures + .ok_or_else(|| Error::Constraint(r"string surrounded by `{{` and `}}`".into()))? .get(1) - .ok_or_else(|| Error::Constraint("variable to be at least one character long".into()))? + .ok_or_else(|| Error::Unexpected("empty variable"))? .as_str()); } impl VariableExpanding for Value where toml::Value: As, - T: Copy, { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { match &self.0 { - ValueEnum::Literal(_) => (), + ValueEnum::Literal(_) => return Ok(()), ValueEnum::Variable(str) => { let name = variable_name(&str)?; - if name == var { - self.0 = ValueEnum::Literal(As::::astype(value).ok_or_else(|| { - Error::Constraint(format!( - "variable of type `{}`, found {}", - std::any::type_name::(), - value - )) - })?); - } + let value = match getter(name)? { + Some(x) => x, + None => return Ok(()), + }; + self.0 = ValueEnum::Literal(As::::astype(&value).ok_or_else(|| { + Error::Constraint(format!( + "variable of type `{}`, found {}", + std::any::type_name::(), + value + )) + })?); + return Ok(()); } }; - return Ok(()); } } @@ -214,15 +289,42 @@ where }; } } + impl VariableExpanding for String { - fn expand_value(&mut self, var: &str, value: &toml::Value) -> Result<()> { - let output = match value { - toml::Value::String(x) => x.clone(), - _ => value.to_string(), - }; - let new_value = self.replace(&format!("{}{var}{}", "{{", "}}"), &output); + fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> + where + F: Fn(&str) -> Result>, + F: Clone, + { + let mut result = String::new(); + let mut last_match = 0..0; + for m in VAR_STRING.find_iter(self) { + let r = m.range(); + + result.push_str(&self[last_match.end..r.start]); + let var = &self[(r.start + 2)..(r.end - 2)]; + let value = match getter(&var)? { + Some(x) => x, + None => { + result.push_str(&self[r.start..r.end]); + last_match = r; + continue; + } + }; + let output = match value { + toml::Value::String(x) => x.clone(), + _ => value.to_string(), + }; + result.push_str(&output); + last_match = r; + } + + if last_match.end < self.len() { + result.push_str(&self[last_match.end..]) + } self.clear(); - self.push_str(&new_value); - Ok(()) + self.push_str(&result); + + return Ok(()); } } From 8d9cefb6240fbbadda8965cfa92d29e36c595bf4 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 13 Aug 2025 15:02:40 -0400 Subject: [PATCH 28/79] basic unit tests for `define` working Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 54 ++++++++++++------------- src/rust/parsing/src/bind.rs | 2 +- src/rust/parsing/src/define.rs | 72 ++++++++-------------------------- 3 files changed, 45 insertions(+), 83 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c19905e2..0f34aa67 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#43f90b", + "statusBarItem.warningBackground": "#dbd533", "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#43f90b", + "statusBarItem.warningHoverBackground": "#dbd533", "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#50ff18", + "statusBarItem.remoteBackground": "#e8e240", "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#5dff25", + "statusBarItem.remoteHoverBackground": "#f5ef4d", "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#43f90b", + "statusBar.background": "#dbd533", "statusBar.foreground": "#000000", - "statusBar.border": "#43f90b", - "statusBar.debuggingBackground": "#43f90b", + "statusBar.border": "#dbd533", + "statusBar.debuggingBackground": "#dbd533", "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#43f90b", - "statusBar.noFolderBackground": "#43f90b", + "statusBar.debuggingBorder": "#dbd533", + "statusBar.noFolderBackground": "#dbd533", "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#43f90b", - "statusBar.prominentBackground": "#43f90b", + "statusBar.noFolderBorder": "#dbd533", + "statusBar.prominentBackground": "#dbd533", "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#43f90b", + "statusBar.prominentHoverBackground": "#dbd533", "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#43f90b99", - "progressBar.background": "#43f90b", - "textLink.foreground": "#83ff4b", - "textLink.activeForeground": "#90ff58", - "selection.background": "#36ec00", - "list.highlightForeground": "#43f90b", - "list.focusAndSelectionOutline": "#43f90b99", - "button.background": "#43f90b", + "focusBorder": "#dbd53399", + "progressBar.background": "#dbd533", + "textLink.foreground": "#ffff73", + "textLink.activeForeground": "#ffff80", + "selection.background": "#cec826", + "list.highlightForeground": "#dbd533", + "list.focusAndSelectionOutline": "#dbd53399", + "button.background": "#dbd533", "button.foreground": "#000000", - "button.hoverBackground": "#50ff18", - "tab.activeBorderTop": "#50ff18", - "pickerGroup.foreground": "#50ff18", - "list.activeSelectionBackground": "#43f90b4d", - "panelTitle.activeBorder": "#50ff18", - "activityBar.activeBorder": "#43f90b", + "button.hoverBackground": "#e8e240", + "tab.activeBorderTop": "#e8e240", + "pickerGroup.foreground": "#e8e240", + "list.activeSelectionBackground": "#dbd5334d", + "panelTitle.activeBorder": "#e8e240", + "activityBar.activeBorder": "#dbd533", "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#43f90b" + "activityBarBadge.background": "#dbd533" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 3cbe1dde..cbea5c94 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -342,7 +342,7 @@ impl CommandInput { #[derive(Clone, Debug, Serialize)] pub struct Command { pub command: String, - args: toml::Table, + pub(crate) args: toml::Table, } #[wasm_bindgen] diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 56b89e3f..3f3b3cfb 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -276,63 +276,25 @@ mod tests { .as_integer() .unwrap(), 1 - ) + ); - // let ref foo = result.bind.as_ref().unwrap().get("foo").unwrap().as_ref(); - // assert_eq!(foo.key.as_ref().as_ref().unwrap(), "x"); - // assert_eq!(foo.command.as_ref().as_ref().unwrap(), "foo"); - // assert_eq!( - // foo.args - // .as_ref() - // .unwrap() - // .as_ref() - // .get("k") - // .unwrap() - // .as_integer() - // .unwrap(), - // 1 - // ); - // assert_eq!( - // foo.args - // .as_ref() - // .unwrap() - // .as_ref() - // .get("h") - // .unwrap() - // .as_integer() - // .unwrap(), - // 2 - // ); - - // let foobar = result - // .command - // .as_ref() - // .unwrap() - // .get("foobar") - // .unwrap() - // .as_ref(); - // assert_eq!(foobar.command.as_ref().as_ref().unwrap(), "runCommands"); - // let commands = foobar - // .args - // .as_ref() - // .unwrap() - // .as_ref() - // .get("commands") - // .unwrap(); - // let command_list = commands.as_array().unwrap(); - // assert_eq!(command_list[0].as_str().unwrap(), "foo"); - // assert_eq!(command_list[1].as_str().unwrap(), "bar"); + assert_eq!( + foo.args + .as_ref() + .unwrap() + .get_ref() + .get("h") + .unwrap() + .as_integer() + .unwrap(), + 2 + ); - // let define = Define::new(result); - // let foo_out = define - // .as_ref() - // .unwrap() - // .bind - // .as_ref() - // .unwrap() - // .get("foo") - // .unwrap(); - // assert_eq!(foo_out.commands[0].command, "foo"); + let foobar = result.command.get("foobar").unwrap(); + assert_eq!(foobar.command, "runCommands"); + let commands = foobar.args.get("commands").unwrap().as_array().unwrap(); + assert_eq!(commands[0].as_str().unwrap(), "foo"); + assert_eq!(commands[1].as_str().unwrap(), "bar"); } } From 3d342f310dd398ba01c284d72782d25dddf77bb0 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 13 Aug 2025 15:03:01 -0400 Subject: [PATCH 29/79] wip variable resolution for `define` Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 54 +++++++++--------- src/rust/parsing/src/define.rs | 58 ++++++++++++++++++- src/rust/parsing/src/variable.rs | 95 ++++++++++++++++++++++++-------- 3 files changed, 157 insertions(+), 50 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 0f34aa67..5aab67f0 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#dbd533", + "statusBarItem.warningBackground": "#09df01", "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#dbd533", + "statusBarItem.warningHoverBackground": "#09df01", "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#e8e240", + "statusBarItem.remoteBackground": "#16ec0e", "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#f5ef4d", + "statusBarItem.remoteHoverBackground": "#23f91b", "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#dbd533", + "statusBar.background": "#09df01", "statusBar.foreground": "#000000", - "statusBar.border": "#dbd533", - "statusBar.debuggingBackground": "#dbd533", + "statusBar.border": "#09df01", + "statusBar.debuggingBackground": "#09df01", "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#dbd533", - "statusBar.noFolderBackground": "#dbd533", + "statusBar.debuggingBorder": "#09df01", + "statusBar.noFolderBackground": "#09df01", "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#dbd533", - "statusBar.prominentBackground": "#dbd533", + "statusBar.noFolderBorder": "#09df01", + "statusBar.prominentBackground": "#09df01", "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#dbd533", + "statusBar.prominentHoverBackground": "#09df01", "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#dbd53399", - "progressBar.background": "#dbd533", - "textLink.foreground": "#ffff73", - "textLink.activeForeground": "#ffff80", - "selection.background": "#cec826", - "list.highlightForeground": "#dbd533", - "list.focusAndSelectionOutline": "#dbd53399", - "button.background": "#dbd533", + "focusBorder": "#09df0199", + "progressBar.background": "#09df01", + "textLink.foreground": "#49ff41", + "textLink.activeForeground": "#56ff4e", + "selection.background": "#00d200", + "list.highlightForeground": "#09df01", + "list.focusAndSelectionOutline": "#09df0199", + "button.background": "#09df01", "button.foreground": "#000000", - "button.hoverBackground": "#e8e240", - "tab.activeBorderTop": "#e8e240", - "pickerGroup.foreground": "#e8e240", - "list.activeSelectionBackground": "#dbd5334d", - "panelTitle.activeBorder": "#e8e240", - "activityBar.activeBorder": "#dbd533", + "button.hoverBackground": "#16ec0e", + "tab.activeBorderTop": "#16ec0e", + "pickerGroup.foreground": "#16ec0e", + "list.activeSelectionBackground": "#09df014d", + "panelTitle.activeBorder": "#16ec0e", + "activityBar.activeBorder": "#09df01", "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#dbd533" + "activityBarBadge.background": "#09df01" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 3f3b3cfb..d4770543 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -239,7 +239,7 @@ mod tests { use super::*; #[test] - fn complete_parsing() { + fn simple_parsing() { let data = r#" [[var]] y = "bill" @@ -296,6 +296,62 @@ mod tests { assert_eq!(commands[0].as_str().unwrap(), "foo"); assert_eq!(commands[1].as_str().unwrap(), "bar"); } + + #[test] + fn parsing_resolved_variables() { + let data = r#" + [[var]] + foo = 1 + + [[var]] + foo_string = "number-{{foo}}" + + [[command]] + id = "run_shebang" + command = "shebang" + args.a = 1 + args.b = "{{foo_string}}" + + [[bind]] + id = "whole_shebang" + key = "a" + name = "the whole shebang" + command = "runCommands" + args.commands = ["{{command.run_shebang}}", "bar"] + "#; + + let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); + let bind_args = result + .bind + .get("whole_shebang") + .as_ref() + .unwrap() + .args + .as_ref() + .unwrap(); + let bind_commands = bind_args + .get_ref() + .get("commands") + .unwrap() + .as_array() + .unwrap(); + info!("{:?}", bind_commands[0]); + assert_eq!( + bind_commands[0].get("command").unwrap().as_str().unwrap(), + "shebang" + ); + assert_eq!( + bind_commands[0] + .get("args") + .unwrap() + .get("b") + .unwrap() + .as_str() + .unwrap(), + "number-1" + ); + assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); + } } // TODO: tests diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index 55d4d8c9..a0b847a6 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -111,30 +111,75 @@ impl VariableExpanding for toml::map::Map { } } +fn expand_to_value(value: &mut toml::Value, getter: F) -> ResultVec +where + F: Fn(&str) -> Result>, + F: Clone, +{ + match value { + toml::Value::String(str) => { + let captures = VAR_STRING.captures(str); + if let Some(c) = captures { + if c.get(0).unwrap().end() == str.len() { + let var = c.get(1).expect("variable capture group").as_str(); + let expanded = getter(var)?.unwrap_or_else(|| value.clone()); + return Ok(expanded); + } + } + + str.expand_with_getter(getter); + return Ok(value.clone()); + } + _ => { + value.expand_with_getter(getter); + return Ok(value.clone()); + } + } +} + impl VariableExpanding for toml::Value { fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> where F: Fn(&str) -> Result>, F: Clone, { - // TODO: this is one place where we would want to implement pruning - // when computing multiple passes of variable expansion - // we'd need some structure to keep track of where we are in the - // tree and mark certain branches as dead if they return `Ok(false)` - // or any `Err`. - // we could do this with a mutable hash map that maps given - // items to their last return state match self { - toml::Value::String(str) => return str.expand_with_getter(getter), + toml::Value::String(_) => return Ok(()), toml::Value::Array(items) => { - return flatten_errors( - items - .iter_mut() - .map(|i| i.expand_with_getter(getter.clone())), - ); + let mut errors = Vec::::new(); + for i in 0..items.len() { + match expand_to_value(&mut items[i], getter.clone()) { + Err(ref mut err) => { + errors.append(err); + } + Ok(value) => { + items[i] = value; + } + } + } + if errors.len() > 0 { + return Err(errors); + } else { + return Ok(()); + } } - toml::Value::Table(kv) => return kv.expand_with_getter(getter.clone()), - _ => return Ok(()), + toml::Value::Table(kv) => { + let mut errors = Vec::new(); + let keys: Vec = kv.keys().map(String::clone).collect(); + for k in keys { + match expand_to_value(&mut kv[&k], getter.clone()) { + Err(err) => { + errors.push(err); + } + Ok(value) => { + kv.insert(k.clone(), value); + } + } + } + return Ok(()); + } + toml::Value::Boolean(_) | toml::Value::Datetime(_) => return Ok(()), + toml::Value::Float(_) | toml::Value::Integer(_) => return Ok(()), } } } @@ -206,16 +251,22 @@ where } lazy_static! { - static ref VAR_STRING: Regex = Regex::new(r"^\{\{(.+)\}\}$").unwrap(); + static ref VAR_STRING: Regex = Regex::new(r"\{\{(.+)\}\}").unwrap(); } fn variable_name(x: &str) -> Result<&str> { - return Ok(VAR_STRING - .captures(x) - .ok_or_else(|| Error::Constraint(r"string surrounded by `{{` and `}}`".into()))? - .get(1) - .ok_or_else(|| Error::Unexpected("empty variable"))? - .as_str()); + if VAR_STRING.captures(x).is_some_and(|c| c.len() == x.len()) { + return Ok(VAR_STRING + .captures(x) + .ok_or_else(|| Error::Constraint(r"string starts and ends with `{{` and `}}`".into()))? + .get(1) + .ok_or_else(|| Error::Unexpected("empty variable"))? + .as_str()); + } else { + return Err(Error::Constraint( + r"string starts and ends with `{{` and `}}`".into(), + ))?; + } } impl VariableExpanding for Value From 44314394fc6c712473cc78bf5314ecd1aaddce8f Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 13 Aug 2025 15:49:42 -0400 Subject: [PATCH 30/79] basic variable resolution for `define` is working Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/define.rs | 6 +++-- src/rust/parsing/src/variable.rs | 46 +++++++++++++++++--------------- 2 files changed, 29 insertions(+), 23 deletions(-) diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index d4770543..c9971f9d 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -304,13 +304,13 @@ mod tests { foo = 1 [[var]] - foo_string = "number-{{foo}}" + foo_string = "number-{{var.foo}}" [[command]] id = "run_shebang" command = "shebang" args.a = 1 - args.b = "{{foo_string}}" + args.b = "{{var.foo_string}}" [[bind]] id = "whole_shebang" @@ -352,6 +352,8 @@ mod tests { ); assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); } + + // TODO: implement tests that show resolution errors in the proper places } // TODO: tests diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index a0b847a6..80839c57 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -104,10 +104,19 @@ impl VariableExpanding for toml::map::Map { F: Fn(&str) -> Result>, F: Clone, { - return flatten_errors( - self.iter_mut() - .map(|(_, v)| v.expand_with_getter(getter.clone())), - ); + let mut errors = Vec::new(); + let keys: Vec = self.keys().map(String::clone).collect(); + for k in keys { + match expand_to_value(&mut self[&k], getter.clone()) { + Err(err) => { + errors.push(err); + } + Ok(value) => { + self.insert(k.clone(), value); + } + } + } + return Ok(()); } } @@ -127,11 +136,11 @@ where } } - str.expand_with_getter(getter); + str.expand_with_getter(getter)?; return Ok(value.clone()); } _ => { - value.expand_with_getter(getter); + value.expand_with_getter(getter)?; return Ok(value.clone()); } } @@ -144,7 +153,10 @@ impl VariableExpanding for toml::Value { F: Clone, { match self { - toml::Value::String(_) => return Ok(()), + toml::Value::String(x) => { + x.expand_with_getter(getter)?; + return Ok(()); + } toml::Value::Array(items) => { let mut errors = Vec::::new(); for i in 0..items.len() { @@ -164,19 +176,7 @@ impl VariableExpanding for toml::Value { } } toml::Value::Table(kv) => { - let mut errors = Vec::new(); - let keys: Vec = kv.keys().map(String::clone).collect(); - for k in keys { - match expand_to_value(&mut kv[&k], getter.clone()) { - Err(err) => { - errors.push(err); - } - Ok(value) => { - kv.insert(k.clone(), value); - } - } - } - return Ok(()); + return kv.expand_with_getter(getter); } toml::Value::Boolean(_) | toml::Value::Datetime(_) => return Ok(()), toml::Value::Float(_) | toml::Value::Integer(_) => return Ok(()), @@ -251,7 +251,8 @@ where } lazy_static! { - static ref VAR_STRING: Regex = Regex::new(r"\{\{(.+)\}\}").unwrap(); + static ref VAR_STRING: Regex = Regex::new(r"\{\{(.*)\}\}").unwrap(); + static ref TEST_STRING: Regex = Regex::new(r"\{(.)").unwrap(); } fn variable_name(x: &str) -> Result<&str> { @@ -369,6 +370,9 @@ impl VariableExpanding for String { result.push_str(&output); last_match = r; } + if last_match.start == 0 && last_match.end == 0 { + return Ok(()); + } if last_match.end < self.len() { result.push_str(&self[last_match.end..]) From 99d888ed2198bd9180407cf782ac4450e7f74f3c Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 16 Aug 2025 00:04:54 -0400 Subject: [PATCH 31/79] `define` variable exapnsion wip Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 88 ++--- notes.md | 8 +- src/presets/larkin.toml | 8 +- src/rust/parsing/Cargo.lock | 414 +----------------------- src/rust/parsing/Cargo.toml | 2 +- src/rust/parsing/src/bind.rs | 204 +++++------- src/rust/parsing/src/bind/foreach.rs | 12 +- src/rust/parsing/src/bind/validation.rs | 202 ++++++++---- src/rust/parsing/src/define.rs | 152 +++++++-- src/rust/parsing/src/error.rs | 4 +- src/rust/parsing/src/file.rs | 2 +- src/rust/parsing/src/variable.rs | 76 +++-- 12 files changed, 450 insertions(+), 722 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 5aab67f0..94309f63 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,52 +17,52 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#09df01", - "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#09df01", - "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#16ec0e", - "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#23f91b", - "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#09df01", - "statusBar.foreground": "#000000", - "statusBar.border": "#09df01", - "statusBar.debuggingBackground": "#09df01", - "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#09df01", - "statusBar.noFolderBackground": "#09df01", - "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#09df01", - "statusBar.prominentBackground": "#09df01", - "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#09df01", - "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#09df0199", - "progressBar.background": "#09df01", - "textLink.foreground": "#49ff41", - "textLink.activeForeground": "#56ff4e", - "selection.background": "#00d200", - "list.highlightForeground": "#09df01", - "list.focusAndSelectionOutline": "#09df0199", - "button.background": "#09df01", - "button.foreground": "#000000", - "button.hoverBackground": "#16ec0e", - "tab.activeBorderTop": "#16ec0e", - "pickerGroup.foreground": "#16ec0e", - "list.activeSelectionBackground": "#09df014d", - "panelTitle.activeBorder": "#16ec0e", - "activityBar.activeBorder": "#09df01", - "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#09df01" + "statusBarItem.warningBackground": "#c82314", + "statusBarItem.warningForeground": "#ffffff", + "statusBarItem.warningHoverBackground": "#c82314", + "statusBarItem.warningHoverForeground": "#ffffff90", + "statusBarItem.remoteBackground": "#d53021", + "statusBarItem.remoteForeground": "#ffffff", + "statusBarItem.remoteHoverBackground": "#e23d2e", + "statusBarItem.remoteHoverForeground": "#ffffff90", + "statusBar.background": "#c82314", + "statusBar.foreground": "#ffffff", + "statusBar.border": "#c82314", + "statusBar.debuggingBackground": "#c82314", + "statusBar.debuggingForeground": "#ffffff", + "statusBar.debuggingBorder": "#c82314", + "statusBar.noFolderBackground": "#c82314", + "statusBar.noFolderForeground": "#ffffff", + "statusBar.noFolderBorder": "#c82314", + "statusBar.prominentBackground": "#c82314", + "statusBar.prominentForeground": "#ffffff", + "statusBar.prominentHoverBackground": "#c82314", + "statusBar.prominentHoverForeground": "#ffffff90", + "focusBorder": "#c8231499", + "progressBar.background": "#c82314", + "textLink.foreground": "#ff6354", + "textLink.activeForeground": "#ff7061", + "selection.background": "#bb1607", + "list.highlightForeground": "#c82314", + "list.focusAndSelectionOutline": "#c8231499", + "button.background": "#c82314", + "button.foreground": "#ffffff", + "button.hoverBackground": "#d53021", + "tab.activeBorderTop": "#d53021", + "pickerGroup.foreground": "#d53021", + "list.activeSelectionBackground": "#c823144d", + "panelTitle.activeBorder": "#d53021", + "activityBar.activeBorder": "#c82314", + "activityBarBadge.foreground": "#ffffff", + "activityBarBadge.background": "#c82314" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", - "projectColors.mainColor": "#681dd7", + "projectColors.mainColor": "#31da1b", "projectColors.isActivityBarColored": false, - "projectColors.isTitleBarColored": false, - "projectColors.isStatusBarColored": false, - "projectColors.isProjectNameColored": false, - "projectColors.isActiveItemsColored": false, - "projectColors.setWindowTitle": false, + "projectColors.isTitleBarColored": true, + "projectColors.isStatusBarColored": true, + "projectColors.isProjectNameColored": true, + "projectColors.isActiveItemsColored": true, + "projectColors.setWindowTitle": true, } diff --git a/notes.md b/notes.md index 56e46433..942151d3 100644 --- a/notes.md +++ b/notes.md @@ -93,11 +93,17 @@ Integration test debugging: - [X] problem: spannd doesn't work with flatten; we can solve this by creating an `id` field for `command` and `bind` that will throw an error if populatd when passed on to the non-input constructors + - [x] setup default keyword for `bind` + - [ ] rework how `var.` works, resolving it at run time, not definition time - [~] unit tests for `define` parsing - - [ ] get basic interpolation of `{{var}}` from `define` elements working for `bind` and its fields + - [ ] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - [ ] implement `default` keyword for `bind` + - [ ] get evaluation of computed elements working + - [ ] use rhai to implement expression evaluation + - [ ] disable keywords/features that are for multiline or assignment - [ ] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) + - [ ] implement support for tags on `bind` (for filter them) - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] foreach expansion within a KeyFile context diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index ff7effe4..e44b6ff7 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -223,8 +223,8 @@ tags = ["motion"] id = "edit_motion_prim" default = "{{bind.edit_motion}}" command = "cursorMove" -value = "{{count}}" -select = "{{editorHasSelection || var.select}}" +args.value = "{{count}}" +args.select = "{{editorHasSelection || var.select}}" [[bind]] default = "{{bind.edit_motion_prim}}" @@ -300,7 +300,7 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true, value = "count" } +args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" } [[bind.args.commands]] command = "expandLineSelection" @@ -321,7 +321,7 @@ command = "selection-utilities.shrinkToActive" [[bind.args.commands]] command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true, value = "count" } +args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" } [[bind.args.commands]] command = "expandLineSelection" diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index edf94777..31bf2132 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -79,52 +79,6 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" -[[package]] -name = "darling" -version = "0.20.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee" -dependencies = [ - "darling_core", - "darling_macro", -] - -[[package]] -name = "darling_core" -version = "0.20.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e" -dependencies = [ - "fnv", - "ident_case", - "proc-macro2", - "quote", - "strsim", - "syn", -] - -[[package]] -name = "darling_macro" -version = "0.20.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead" -dependencies = [ - "darling_core", - "quote", - "syn", -] - -[[package]] -name = "displaydoc" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "env_filter" version = "0.1.3" @@ -154,140 +108,12 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" -[[package]] -name = "fnv" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" - -[[package]] -name = "form_urlencoded" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" -dependencies = [ - "percent-encoding", -] - [[package]] name = "hashbrown" version = "0.15.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" -[[package]] -name = "icu_collections" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47" -dependencies = [ - "displaydoc", - "potential_utf", - "yoke", - "zerofrom", - "zerovec", -] - -[[package]] -name = "icu_locale_core" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a" -dependencies = [ - "displaydoc", - "litemap", - "tinystr", - "writeable", - "zerovec", -] - -[[package]] -name = "icu_normalizer" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979" -dependencies = [ - "displaydoc", - "icu_collections", - "icu_normalizer_data", - "icu_properties", - "icu_provider", - "smallvec", - "zerovec", -] - -[[package]] -name = "icu_normalizer_data" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3" - -[[package]] -name = "icu_properties" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b" -dependencies = [ - "displaydoc", - "icu_collections", - "icu_locale_core", - "icu_properties_data", - "icu_provider", - "potential_utf", - "zerotrie", - "zerovec", -] - -[[package]] -name = "icu_properties_data" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632" - -[[package]] -name = "icu_provider" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af" -dependencies = [ - "displaydoc", - "icu_locale_core", - "stable_deref_trait", - "tinystr", - "writeable", - "yoke", - "zerofrom", - "zerotrie", - "zerovec", -] - -[[package]] -name = "ident_case" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" - -[[package]] -name = "idna" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e" -dependencies = [ - "idna_adapter", - "smallvec", - "utf8_iter", -] - -[[package]] -name = "idna_adapter" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" -dependencies = [ - "icu_normalizer", - "icu_properties", -] - [[package]] name = "indexmap" version = "2.10.0" @@ -296,6 +122,7 @@ checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661" dependencies = [ "equivalent", "hashbrown", + "serde", ] [[package]] @@ -304,12 +131,6 @@ version = "1.70.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf" -[[package]] -name = "itoa" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c" - [[package]] name = "jiff" version = "0.2.15" @@ -350,12 +171,6 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" -[[package]] -name = "litemap" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956" - [[package]] name = "log" version = "0.4.27" @@ -410,6 +225,7 @@ name = "parsing" version = "0.1.0" dependencies = [ "env_logger", + "indexmap", "js-sys", "lazy_static", "log", @@ -420,16 +236,9 @@ dependencies = [ "test-log", "thiserror", "toml", - "validator", "wasm-bindgen", ] -[[package]] -name = "percent-encoding" -version = "2.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" - [[package]] name = "pin-project-lite" version = "0.2.16" @@ -451,37 +260,6 @@ dependencies = [ "portable-atomic", ] -[[package]] -name = "potential_utf" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585" -dependencies = [ - "zerovec", -] - -[[package]] -name = "proc-macro-error-attr2" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" -dependencies = [ - "proc-macro2", - "quote", -] - -[[package]] -name = "proc-macro-error2" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" -dependencies = [ - "proc-macro-error-attr2", - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "proc-macro2" version = "1.0.97" @@ -550,12 +328,6 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" -[[package]] -name = "ryu" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f" - [[package]] name = "serde" version = "1.0.219" @@ -587,18 +359,6 @@ dependencies = [ "syn", ] -[[package]] -name = "serde_json" -version = "1.0.142" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7" -dependencies = [ - "itoa", - "memchr", - "ryu", - "serde", -] - [[package]] name = "serde_spanned" version = "1.0.0" @@ -617,18 +377,6 @@ dependencies = [ "lazy_static", ] -[[package]] -name = "smallvec" -version = "1.15.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" - -[[package]] -name = "stable_deref_trait" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" - [[package]] name = "string-offsets" version = "0.2.0" @@ -638,12 +386,6 @@ dependencies = [ "wasm-bindgen", ] -[[package]] -name = "strsim" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" - [[package]] name = "syn" version = "2.0.104" @@ -655,17 +397,6 @@ dependencies = [ "unicode-ident", ] -[[package]] -name = "synstructure" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "test-log" version = "0.2.18" @@ -717,16 +448,6 @@ dependencies = [ "cfg-if", ] -[[package]] -name = "tinystr" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b" -dependencies = [ - "displaydoc", - "zerovec", -] - [[package]] name = "toml" version = "0.9.5" @@ -820,59 +541,12 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" -[[package]] -name = "url" -version = "2.5.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60" -dependencies = [ - "form_urlencoded", - "idna", - "percent-encoding", -] - -[[package]] -name = "utf8_iter" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" - [[package]] name = "utf8parse" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" -[[package]] -name = "validator" -version = "0.20.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43fb22e1a008ece370ce08a3e9e4447a910e92621bb49b85d6e48a45397e7cfa" -dependencies = [ - "idna", - "once_cell", - "regex", - "serde", - "serde_derive", - "serde_json", - "url", - "validator_derive", -] - -[[package]] -name = "validator_derive" -version = "0.20.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7df16e474ef958526d1205f6dda359fdfab79d9aa6d54bafcb92dcd07673dca" -dependencies = [ - "darling", - "once_cell", - "proc-macro-error2", - "proc-macro2", - "quote", - "syn", -] - [[package]] name = "valuable" version = "0.1.1" @@ -1044,87 +718,3 @@ name = "winnow" version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95" - -[[package]] -name = "writeable" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb" - -[[package]] -name = "yoke" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc" -dependencies = [ - "serde", - "stable_deref_trait", - "yoke-derive", - "zerofrom", -] - -[[package]] -name = "yoke-derive" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "synstructure", -] - -[[package]] -name = "zerofrom" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" -dependencies = [ - "zerofrom-derive", -] - -[[package]] -name = "zerofrom-derive" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" -dependencies = [ - "proc-macro2", - "quote", - "syn", - "synstructure", -] - -[[package]] -name = "zerotrie" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595" -dependencies = [ - "displaydoc", - "yoke", - "zerofrom", -] - -[[package]] -name = "zerovec" -version = "0.11.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7aa2bd55086f1ab526693ecbe444205da57e25f4489879da80635a46d90e73b" -dependencies = [ - "yoke", - "zerofrom", - "zerovec-derive", -] - -[[package]] -name = "zerovec-derive" -version = "0.11.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 86217969..7474b2d8 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" [dependencies] env_logger = "0.11.8" +indexmap = { version = "2.10.0", features = ["serde"] } js-sys = "0.3.77" lazy_static = "1.5.0" log = { version = "0.4.27", features = ["release_max_level_error"] } @@ -15,7 +16,6 @@ string-offsets = { version = "0.2.0", features = ["wasm"] } test-log = "0.2.18" thiserror = "2.0.12" toml = { version = "0.9.2", features = ["preserve_order"] } -validator = { version = "0.20.0", features = ["derive"] } wasm-bindgen = "0.2.100" [lib] diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index cbea5c94..a9054274 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -6,9 +6,9 @@ mod foreach; mod validation; use crate::bind::foreach::expand_keys; -use crate::bind::validation::{JsonObjectShape, valid_json_array_object, valid_key_binding}; +use crate::bind::validation::{BindingReference, KeyBinding}; use crate::error::{ - Context, ErrorContext, ErrorContexts, Result, ResultVec, constrain, reserved, unexpected, + ErrorContext, ErrorContexts, Result, ResultVec, constrain, reserved, unexpected, }; use crate::util::{Merging, Plural, Required, Requiring, Resolving}; use crate::variable; @@ -16,10 +16,11 @@ use crate::variable::VariableExpanding; #[allow(unused_imports)] use log::info; + +use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; use toml::{Spanned, Value}; -use validator::Validate; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; @@ -57,7 +58,7 @@ fn span_plural_default() -> Spanned> { * a `*`. * */ -#[derive(Serialize, Deserialize, Validate, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug)] pub struct BindingInput { // should only be `Some` in context of `Define(Input)` pub(crate) id: Option>, @@ -79,7 +80,6 @@ pub struct BindingInput { * - `args`: The arguments to directly pass to the `command`, these are static * values. */ - #[validate(custom(function = "JsonObjectShape::valid_json_object"))] #[serde(default)] pub args: Option>, @@ -91,8 +91,7 @@ pub struct BindingInput { * triggers `command`. */ #[serde(default = "span_required_default")] - #[validate(custom(function = "valid_key_binding"))] - pub key: Spanned>, + pub key: Spanned>, /** * @forBindingField bind * @@ -124,11 +123,12 @@ pub struct BindingInput { /** * @forBindingField bind * - * - `defaults`: the hierarchy of defaults applied to this binding, see - * [`default`](/bindings/default) for more details. + * - `default`: the default values to use for fields, specified as + * string of the form `{{bind.[name]}}`. + * See [`define`](/bindings/define) for more details. */ #[serde(default)] - pub defaults: Option>, + pub default: Option>, /** * @forBindingField bind * @@ -136,8 +136,7 @@ pub struct BindingInput { * [`foreach` clauses](#foreach-clauses). */ #[serde(default)] - #[validate(custom(function = "valid_json_array_object"))] - pub foreach: Option>, + pub foreach: Option>>>, /** * @forBindingField bind @@ -255,7 +254,7 @@ impl BindingInput { when: self.when.clone(), mode: self.mode.clone(), priority: self.priority.clone(), - defaults: self.defaults.clone(), + default: self.default.clone(), foreach: self.foreach.clone(), prefixes: self.prefixes.clone(), finalKey: self.finalKey.clone(), @@ -285,7 +284,7 @@ impl Merging for BindingInput { when: self.when.coalesce(y.when), mode: self.mode.coalesce(y.mode), priority: self.priority.coalesce(y.priority), - defaults: self.defaults.coalesce(y.defaults), + default: self.default.coalesce(y.default), foreach: self.foreach, prefixes: self.prefixes.coalesce(y.prefixes), finalKey: self.finalKey.coalesce(y.finalKey), @@ -379,7 +378,6 @@ pub struct Binding { pub when: Vec, pub mode: Vec, pub priority: i64, - pub defaults: String, pub prefixes: Vec, pub finalKey: bool, pub repeat: Option, @@ -400,7 +398,7 @@ pub struct Binding { impl BindingInput { fn has_foreach(&self) -> bool { if let Some(foreach) = &self.foreach { - return foreach.get_ref().len() > 0; + return foreach.len() > 0; } return false; } @@ -414,37 +412,31 @@ impl BindingInput { } fn expand_foreach_once(&mut self, inputs: &Vec) -> ResultVec> { - let foreach = match &self.foreach { - Some(foreach) => foreach.get_ref(), - None => &toml::map::Map::new(), + let foreach = match self.foreach { + Some(ref mut foreach) => foreach, + None => &mut IndexMap::new(), }; - let mut final_foreach = foreach.clone(); + let final_foreach = foreach.split_off(1); let mut iter = foreach.iter(); let first = iter.next(); if let Some(item) = first { let (var, values) = item; - final_foreach.remove(var); - - if let Value::Array(items) = values { - let expanded_items = - expand_keys(items).context_str(format!("while reading {}", values))?; - let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); - for input in inputs { - for value in &expanded_items { - let mut expanded = input.clone(); - expanded.expand_value(var, value)?; - result.push(expanded); - } - } - if final_foreach.len() > 0 { - self.foreach = Some(Spanned::new(UNKNOWN_RANGE, final_foreach)); - } else { - self.foreach = None; + + let expanded_items = expand_keys(values)?; + let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); + for input in inputs { + for value in &expanded_items { + let mut expanded = input.clone(); + expanded.expand_value(var, value)?; + result.push(expanded); } - return Ok(result); + } + if final_foreach.len() > 0 { + self.foreach = Some(final_foreach); } else { - return unexpected("`foreach` was not an object of arrays")?; + self.foreach = None; } + return Ok(result); } else { return Ok(vec![]); } @@ -457,78 +449,25 @@ impl VariableExpanding for BindingInput { F: Fn(&str) -> Result>, F: Clone, { - self.command - .expand_with_getter(getter.clone()) - .context_str("`command` field") - .context_range(&self.command)?; - self.args - .expand_with_getter(getter.clone()) - .context_str("`args` field") - .context_range(&self.args)?; - self.key - .expand_with_getter(getter.clone()) - .context_str("`key` field") - .context_range(&self.key)?; - self.when - .expand_with_getter(getter.clone()) - .context_str("`when` field") - .context_range(&self.when)?; - self.mode - .expand_with_getter(getter.clone()) - .context_str("`mode` field") - .context_range(&self.mode)?; - self.priority - .expand_with_getter(getter.clone()) - .context_str("`priority` field") - .context_range(&self.priority)?; - self.defaults - .expand_with_getter(getter.clone()) - .context_str("`defaults` field") - .context_range(&self.defaults)?; - self.prefixes - .expand_with_getter(getter.clone()) - .context_str("`prefixes` field") - .context_range(&self.prefixes)?; - self.finalKey - .expand_with_getter(getter.clone()) - .context_str("`finalKey` field") - .context_range(&self.finalKey)?; - self.repeat - .expand_with_getter(getter.clone()) - .context_str("`repeat` field") - .context_range(&self.repeat)?; - self.name - .expand_with_getter(getter.clone()) - .context_str("`name` field") - .context_range(&self.name)?; - self.description - .expand_with_getter(getter.clone()) - .context_str("`description` field") - .context_range(&self.description)?; - self.hideInPalette - .expand_with_getter(getter.clone()) - .context_str("`hideInPalette` field") - .context_range(&self.hideInPalette)?; - self.hideInDocs - .expand_with_getter(getter.clone()) - .context_str("`hideInDocs` field") - .context_range(&self.hideInDocs)?; - self.combinedName - .expand_with_getter(getter.clone()) - .context_str("`combinedName` field") - .context_range(&self.combinedName)?; - self.combinedKey - .expand_with_getter(getter.clone()) - .context_str("`combinedKey` field") - .context_range(&self.combinedKey)?; + self.command.expand_with_getter(getter.clone())?; + self.args.expand_with_getter(getter.clone())?; + self.key.expand_with_getter(getter.clone())?; + self.when.expand_with_getter(getter.clone())?; + self.mode.expand_with_getter(getter.clone())?; + self.priority.expand_with_getter(getter.clone())?; + self.default.expand_with_getter(getter.clone())?; + self.prefixes.expand_with_getter(getter.clone())?; + self.finalKey.expand_with_getter(getter.clone())?; + self.repeat.expand_with_getter(getter.clone())?; + self.name.expand_with_getter(getter.clone())?; + self.description.expand_with_getter(getter.clone())?; + self.hideInPalette.expand_with_getter(getter.clone())?; + self.hideInDocs.expand_with_getter(getter.clone())?; + self.combinedName.expand_with_getter(getter.clone())?; + self.combinedKey.expand_with_getter(getter.clone())?; self.combinedDescription - .expand_with_getter(getter.clone()) - .context_str("`combinedDescription` field") - .context_range(&self.combinedDescription)?; - self.kind - .expand_with_getter(getter.clone()) - .context_str("`kind` field") - .context_range(&self.kind)?; + .expand_with_getter(getter.clone())?; + self.kind.expand_with_getter(getter.clone())?; return Ok(()); } } @@ -611,14 +550,13 @@ impl Binding { return Ok(Binding { commands: commands, - key: input.key.into_inner().require("`key` field")?, + key: input.key.into_inner().require("`key` field")?.unwrap(), when: input.when.into_inner().to_array(), mode: input.mode.into_inner().to_array(), priority: input .priority .map(|x| x.into_inner().resolve("`priority` field")) .unwrap_or_else(|| Ok(0))?, - defaults: input.defaults.map(|x| x.into_inner()).unwrap_or_default(), prefixes: input.prefixes.into_inner().to_array(), finalKey: input .finalKey @@ -658,7 +596,7 @@ mod tests { when = "joe > 1" mode = "normal" priority = 1 - defaults = "foo.bar" + default = "{{bind.foo_bar}}" foreach.index = [1,2,3] prefixes = "c" finalKey = true @@ -679,14 +617,24 @@ mod tests { let args = result.args.unwrap().into_inner(); assert_eq!(args.get("a").unwrap(), &Value::String("2".into())); assert_eq!(args.get("b").unwrap(), &Value::Integer(3)); - assert_eq!(result.key.into_inner(), Required::Value("a".into())); + assert_eq!(result.key.into_inner().unwrap().unwrap(), "a"); assert_eq!(result.when.into_inner(), Plural::One("joe > 1".into())); assert_eq!(result.mode.into_inner(), Plural::One("normal".into())); assert_eq!(result.priority.map(|x| x.into_inner()).unwrap().unwrap(), 1); - assert_eq!(result.defaults.map(|x| x.into_inner()).unwrap(), "foo.bar"); assert_eq!( - result.foreach.unwrap().into_inner().get("index").unwrap(), - &Value::Array(vec![1, 2, 3].iter().map(|x| Value::Integer(*x)).collect()) + result.default.map(|x| x.into_inner()).as_ref().unwrap(), + &BindingReference::try_from(String::from("{{bind.foo_bar}}")).unwrap() + ); + assert_eq!( + result + .foreach + .unwrap() + .get("index") + .unwrap() + .iter() + .map(|x| x.get_ref().as_integer().unwrap()) + .collect::>(), + vec![1, 2, 3], ); assert_eq!(result.prefixes.into_inner(), Plural::One("c".into())); assert_eq!( @@ -731,7 +679,7 @@ mod tests { "#; let result = toml::from_str::(data).unwrap(); - assert_eq!(result.key.into_inner().unwrap(), "l"); + assert_eq!(result.key.into_inner().unwrap().unwrap(), "l"); assert_eq!(result.command.into_inner().unwrap(), "cursorMove"); assert_eq!( result @@ -769,7 +717,7 @@ mod tests { let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let left = default.merge(left); - assert_eq!(left.key.into_inner().unwrap(), "l"); + assert_eq!(left.key.into_inner().unwrap().unwrap(), "l"); assert_eq!(left.command.into_inner().unwrap(), "cursorMove"); assert_eq!( left.args @@ -884,6 +832,24 @@ mod tests { let mut result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); + // for it in items.iter() { + // info!("{}", "{"); + // info!(" name: {}", it.name.clone().unwrap().get_ref()); + // info!(" command: {}", it.command.get_ref().clone().unwrap()); + // info!( + // " args.value: {}", + // it.args + // .clone() + // .unwrap() + // .get_ref() + // .get("value") + // .unwrap() + // .as_str() + // .unwrap() + // ); + // info!("{}", "}"); + // } + let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; let expected_value = vec!["with-x", "with-y", "with-x", "with-y"]; let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index d2917cc4..c94849d0 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -1,10 +1,10 @@ -use crate::error::Result; +use crate::error::{ErrorContext, Result}; use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use toml::Value; +use toml::{Spanned, Value}; const ALL_KEYS: [&'static str; 192] = [ "f0", @@ -205,13 +205,13 @@ lazy_static! { static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"\{\{\s*key\(\s*`(.*)`\s*\)\s*\}\}").unwrap(); } -pub fn expand_keys(items: &Vec) -> Result> { +pub fn expand_keys(items: &Vec>) -> Result> { let mut result = Vec::new(); for item in items { - if let Value::String(str_item) = item { + if let Value::String(str_item) = item.get_ref() { if let Some(caps) = KEY_PATTERN_REGEX.captures(&str_item) { - let key_regex = Regex::new(&caps[1])?; + let key_regex = Regex::new(&caps[1]).context_range(&item.span())?; for key in ALL_KEYS { if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { result.push(Value::String(key.into())); @@ -220,7 +220,7 @@ pub fn expand_keys(items: &Vec) -> Result> { continue; } } - result.push(item.clone()); + result.push(item.get_ref().clone()); } return Ok(result); } diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index c1e53535..abdd1d9a 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,59 +1,14 @@ -use crate::util::Required; -use lazy_static::lazy_static; -use regex::Regex; -use toml::{Spanned, Value}; -use validator::ValidationError; - -pub fn valid_json_array(values: &Vec) -> std::result::Result<(), ValidationError> { - return values.iter().try_for_each(valid_json_value); -} - -pub trait JsonObjectShape { - fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError>; -} - -impl JsonObjectShape for toml::Table { - fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError> { - return kv.iter().try_for_each(|(_, v)| valid_json_value(v)); - } -} +use crate::error::{Error, ErrorWithContext, Result, ResultVec}; +use crate::util::Merging; +use crate::variable; +use crate::variable::{As, VAR_STRING, Value, ValueEnum, VariableExpanding}; -impl JsonObjectShape for &Spanned { - fn valid_json_object(kv: &Self) -> std::result::Result<(), ValidationError> { - return kv - .get_ref() - .iter() - .try_for_each(|(_, v)| valid_json_value(v)); - } -} - -// we read in TOML values, but only want to accept JSON-valid values in some contexts -// (since that is what we'll be serializing out to) -pub fn valid_json_value(x: &Value) -> std::result::Result<(), ValidationError> { - match x { - Value::Integer(_) | Value::Float(_) | Value::Boolean(_) | Value::String(_) => { - return Ok(()); - } - Value::Datetime(_) => { - return Err(ValidationError::new("DateTime values are not supported")); - } - Value::Array(values) => return valid_json_array(values), - Value::Table(kv) => return toml::Table::valid_json_object(kv), - }; -} - -pub fn valid_json_array_object( - kv: &Spanned, -) -> std::result::Result<(), ValidationError> { - return kv - .as_ref() - .iter() - .try_for_each(|(_, v)| valid_json_value(v)); -} +#[allow(unused_imports)] +use log::info; -trait MapLike { - fn no_reserved_fields(kv: &Self) -> std::result::Result<(), ValidationError>; -} +use lazy_static::lazy_static; +use regex::Regex; +use serde::{Deserialize, Serialize}; lazy_static! { static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); @@ -140,21 +95,6 @@ lazy_static! { ]; } -pub fn valid_key_binding( - val: &Spanned>, -) -> std::result::Result<(), ValidationError> { - match val.get_ref() { - Required::DefaultValue => return Ok(()), - Required::Value(x) => { - if valid_key_binding_str(x) { - return Err(ValidationError::new("Invalid key binding")); - } else { - return Ok(()); - } - } - }; -} - fn valid_key_binding_str(str: &str) -> bool { for press in Regex::new(r"\s+").unwrap().split(str) { let mut first = true; @@ -171,5 +111,127 @@ fn valid_key_binding_str(str: &str) -> bool { } } } - return false; + return true; +} + +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(try_from = "String", into = "String")] +pub struct KeyBinding(ValueEnum); + +impl TryFrom for KeyBinding { + type Error = crate::error::ErrorWithContext; + fn try_from(value: String) -> Result { + if VAR_STRING.is_match(&value) { + return Ok(KeyBinding(ValueEnum::Variable(value))); + } else if !valid_key_binding_str(&value) { + return Err(crate::error::Error::Validation( + "keybinding; must be\ + a sequence of [mod]+[key] values (see \ + https://code.visualstudio.com/docs/getstarted/keybindings#_accepted-keys)", + ))?; + } else { + return Ok(KeyBinding(ValueEnum::Literal(value))); + } + } +} + +impl From for String { + fn from(value: KeyBinding) -> Self { + match value.0 { + ValueEnum::Literal(x) => x, + ValueEnum::Variable(x) => x, + } + } +} + +impl As for toml::Value { + fn astype(&self) -> crate::error::Result { + match self { + toml::Value::String(str) => Ok(KeyBinding::try_from(str.clone())?), + _ => Err(Error::Constraint("a string describing a keybinding".into()))?, + } + } +} + +impl VariableExpanding for KeyBinding { + fn expand_with_getter(&mut self, getter: F) -> crate::error::ResultVec<()> + where + F: Fn(&str) -> crate::error::Result>, + F: Clone, + { + match &mut self.0 { + ValueEnum::Literal(_) => (), + ValueEnum::Variable(str) => { + let mut new_str = str.clone(); + new_str.expand_with_getter(getter)?; + let new = KeyBinding::try_from(new_str)?; + self.0 = new.0; + } + } + return Ok(()); + } +} + +impl Merging for KeyBinding { + fn merge(self, new: Self) -> Self { + return new; + } + fn coalesce(self, new: Self) -> Self { + return new; + } +} + +impl KeyBinding { + pub fn unwrap(self) -> String { + match self.0 { + ValueEnum::Literal(x) => x, + ValueEnum::Variable(_) => panic!("unresolved variable"), + } + } +} + +lazy_static! { + static ref BIND_STRING: Regex = Regex::new(r"\{\{(bind\.[\w--\d]\w*)\}\}").unwrap(); +} + +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] +#[serde(try_from = "String")] +pub struct BindingReference(variable::Value); + +impl TryFrom for BindingReference { + type Error = ErrorWithContext; + fn try_from(value: String) -> Result { + let captures = BIND_STRING.captures(&value).ok_or_else(|| { + crate::error::Error::Validation( + "binding reference; must be of the form `{{bind.[identifier]}})", + ) + })?; + let name = captures.get(1).expect("`bind.` identifier capture"); + return Ok(BindingReference(variable::Value::var(name.as_str().into()))); + } +} + +impl VariableExpanding for BindingReference { + fn expand_with_getter(&mut self, getter: F) -> crate::error::ResultVec<()> + where + F: Fn(&str) -> crate::error::Result>, + F: Clone, + { + return self.0.expand_with_getter(getter); + } +} + +impl Merging for BindingReference { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, new: Self) -> Self { + return new; + } +} + +impl BindingReference { + pub fn unwrap(self) -> toml::Value { + return self.0.unwrap(); + } } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index c9971f9d..3b58dc60 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,3 +1,4 @@ +use core::error; use std::collections::HashMap; use crate::bind::{Binding, BindingInput, Command, CommandInput}; @@ -10,10 +11,9 @@ use log::info; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; use toml::Spanned; -use validator::Validate; use wasm_bindgen::prelude::*; -#[derive(Deserialize, Clone, Debug, Validate)] +#[derive(Deserialize, Serialize, Clone, Debug)] pub struct DefineInput { pub var: Option>>>, pub command: Option>>, @@ -67,10 +67,11 @@ impl Define { let mut resolved_bind = HashMap::>::new(); let mut resolved_command = HashMap::>::new(); let mut resolved_var = HashMap::::new(); + let mut errors = Vec::new(); - // TODO: we don't want to parse expressions that start with a reference - // to a var. command. or bind. variable to be read as a variable reference here - // (also a good thing to writ ea test for down below) + // TODO: we don't want to parse *expressions* that start with a reference to a var. + // command. or bind. (e.g. {{var.a + var.b}}) variable to be read as a variable + // reference here (also a good thing to writ ea test for down below) // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they // must only reference previously defined variables (we've included the TOML feature @@ -78,7 +79,7 @@ impl Define { // same block) for def_block in input.var.into_iter().flatten() { for (var, mut value) in def_block.into_iter() { - value.expand_with_getter(|id| { + let mut var_result = value.expand_with_getter(|id| { if let Some((prefix, name)) = id.split_once('.') { if prefix == "var" { let resolved = resolved_var.get(name). @@ -95,14 +96,17 @@ impl Define { // other types of variables are left unresolved return Ok(None); - })?; + }); + if let Err(ref mut errs) = var_result { + errors.append(errs); + } resolved_var.insert(var.clone(), value.get_ref().clone()); } } // STEP 1b: resolve [[define.command]] blocks for mut def in input.command.into_iter().flatten() { - def.get_mut().expand_with_getter(|id| { + let mut command_result = def.get_mut().expand_with_getter(|id| { if let Some((prefix, name)) = id.split_once('.') { if prefix == "var" { let value = resolved_var @@ -121,7 +125,11 @@ impl Define { } } return Ok(None); - })?; + }); + if let Err(ref mut errs) = command_result { + errors.append(errs); + } + let id = def.get_ref().id.clone(); resolved_command.insert( id.require("id") @@ -134,7 +142,7 @@ impl Define { // STEP 1c: resolve [[define.bind]] blocks for mut def in input.bind.into_iter().flatten() { - def.get_mut().expand_with_getter(|id| { + let mut bind_result = def.get_mut().expand_with_getter(|id| { if let Some((prefix, name)) = id.split_once('.') { if prefix == "var" { let value = resolved_var @@ -154,7 +162,11 @@ impl Define { } } return Ok(None); - })?; + }); + if let Err(ref mut errs) = bind_result { + errors.append(errs); + } + let id = def.get_ref().id.clone(); resolved_bind.insert( id.require("id") @@ -167,21 +179,24 @@ impl Define { // STEP 2: cleanup results for use in `Define` struct - // TODO: because resolution to the Binding and Command structs does not occur until - // later, we could, in theory end up with a *lot* of errors for the same lines, it - // will be important to clean up the output to only show one of these errors and - // remove the other instances; or convince our selves no such issue will arise - let bind = resolved_bind - .into_iter() - .map(|(k, v)| (k, v.into_inner().without_id())) - .collect(); - let command = map_with_err(resolved_command, &mut |c| Command::new(c.without_id()))?; - - return Ok(Define { - bind, - command, - var: resolved_var, - }); + if errors.len() > 0 { + return Err(errors); + } else { + // TODO: because resolution to the Binding and Command structs does not occur until + // later, we could, in theory end up with a *lot* of errors for the same lines, it + // will be important to clean up the output to only show one of these errors and + // remove the other instances; or convince our selves no such issue will arise + let bind = resolved_bind + .into_iter() + .map(|(k, v)| (k, v.into_inner().without_id())) + .collect(); + let command = map_with_err(resolved_command, &mut |c| Command::new(c.without_id()))?; + return Ok(Define { + bind, + command, + var: resolved_var, + }); + } } } @@ -201,6 +216,9 @@ impl Define { } } +// TODO: we don't actually want to resolve `var.`s as they might change during runtime +// TODO: we need to avoid parsing expressions as variables to insert + impl VariableResolver for Define { fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()> { x.expand_with_getter(|var| { @@ -265,7 +283,7 @@ mod tests { assert_eq!(result.var.get("y").unwrap().as_str().unwrap(), "bill"); assert_eq!(result.var.get("joe").unwrap().as_str().unwrap(), "bob"); let foo = result.bind.get("foo").unwrap(); - assert_eq!(foo.key.get_ref().as_ref().unwrap().as_str(), "x"); + assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); assert_eq!( foo.args .as_ref() @@ -335,7 +353,6 @@ mod tests { .unwrap() .as_array() .unwrap(); - info!("{:?}", bind_commands[0]); assert_eq!( bind_commands[0].get("command").unwrap().as_str().unwrap(), "shebang" @@ -353,7 +370,80 @@ mod tests { assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); } - // TODO: implement tests that show resolution errors in the proper places -} + #[test] + fn parsing_order_error() { + let data = r#" + [[var]] + k = "{{command.foo}}" + + [[var]] + a = 1 + + [[var]] + b = "{{var.a}}-boot" + + [[var]] + c = "{{var.not_defined}}-boot" -// TODO: tests + [[command]] + id = "foo" + command = "joe" + args.x = 1 + + [[command]] + id = "bar" + command = "runCommands" + args.commands = ["{{command.biz}}", "baz"] + + [[command]] + id = "biz" + command = "bob" + args.y = 2 + args.x = "{{bind.horace}}" + + [[bind]] + id = "horace" + key = "ctrl+k" + command = "cursorLeft" + args.value = "{{count}}" + + [[bind]] + default = "{{bind.horace}} + id = "bob + key = "ctrl+y" + command = "cursorRight" + + [[bind]] + default = "{{bind.will}} + id = "bob + key = "ctrl+k" + command = "cursorDown" + "#; + // TODO: add `default` key to `bind` so we can accomplish the todo below + // TODO: test for missing `bind` + let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); + assert!(if let Error::ForwardReference(ref str) = result[0].error { + str.starts_with("`command.foo`") + } else { + false + }); + assert!(if let Error::UndefinedVariable(ref str) = result[1].error { + str.starts_with("`var.not_defined`") + } else { + false + }); + assert!(if let Error::UndefinedVariable(ref str) = result[2].error { + str.starts_with("`command.biz`") + } else { + false + }); + assert!(if let Error::ForwardReference(ref str) = result[3].error { + str.starts_with("`bind.horace`") + } else { + false + }); + } + + // - missing `var.`, `bind.` or `command.` values + // - bad order of values thereof +} diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index cc8a8a9f..d6f099b4 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -15,8 +15,8 @@ pub enum Error { Parsing(#[from] toml::de::Error), #[error("serializing {0}")] Serialization(#[from] toml::ser::Error), - #[error("validating {0}")] - Validation(#[from] validator::ValidationError), + #[error("invalid {0}")] + Validation(&'static str), #[error("expected {0}")] Constraint(String), #[error("requires {0}")] diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 27697e3f..2d2d913e 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -10,7 +10,7 @@ use toml::Spanned; use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript -#[derive(Deserialize, Clone, Debug)] +#[derive(Deserialize, Serialize, Clone, Debug)] struct KeyFileInput { define: Option, bind: Option>>, diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index 80839c57..a0fb1438 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -108,15 +108,19 @@ impl VariableExpanding for toml::map::Map { let keys: Vec = self.keys().map(String::clone).collect(); for k in keys { match expand_to_value(&mut self[&k], getter.clone()) { - Err(err) => { - errors.push(err); + Err(ref mut err) => { + errors.append(err); } Ok(value) => { self.insert(k.clone(), value); } } } - return Ok(()); + if errors.len() > 0 { + return Err(errors); + } else { + return Ok(()); + } } } @@ -129,7 +133,7 @@ where toml::Value::String(str) => { let captures = VAR_STRING.captures(str); if let Some(c) = captures { - if c.get(0).unwrap().end() == str.len() { + if c.get(0).unwrap().len() == str.len() { let var = c.get(1).expect("variable capture group").as_str(); let expanded = getter(var)?.unwrap_or_else(|| value.clone()); return Ok(expanded); @@ -197,31 +201,40 @@ impl VariableExpanding for Option { } } -trait As { - fn astype(&self) -> Option; +pub(crate) trait As { + fn astype(&self) -> Result; } impl As for toml::Value { - fn astype(&self) -> Option { - self.as_str().map(|s| s.into()) + fn astype(&self) -> Result { + Ok(self + .as_str() + .map(|s| s.into()) + .ok_or_else(|| Error::Constraint(format!("type String, found {}", self)))?) } } impl As for toml::Value { - fn astype(&self) -> Option { - self.as_bool() + fn astype(&self) -> Result { + Ok(self + .as_bool() + .ok_or_else(|| Error::Constraint(format!("type bool, found {}", self)))?) } } impl As for toml::Value { - fn astype(&self) -> Option { - self.as_integer() + fn astype(&self) -> Result { + Ok(self + .as_integer() + .ok_or_else(|| Error::Constraint(format!("type i64, found {}", self)))?) } } impl As for toml::Value { - fn astype(&self) -> Option { - self.as_float() + fn astype(&self) -> Result { + Ok(self + .as_float() + .ok_or_else(|| Error::Constraint(format!("type f64, found {}", self)))?) } } @@ -229,20 +242,20 @@ impl As for T where T: Clone, { - fn astype(&self) -> Option { - Some(self.clone()) + fn astype(&self) -> Result { + Ok(self.clone()) } } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] #[serde(transparent)] pub struct Value(ValueEnum) where toml::Value: As; -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] #[serde(untagged)] -enum ValueEnum +pub enum ValueEnum where toml::Value: As, { @@ -250,9 +263,17 @@ where Variable(String), } +impl Value +where + toml::Value: As, +{ + pub fn var(x: String) -> Self { + return Value(ValueEnum::Variable(x)); + } +} + lazy_static! { - static ref VAR_STRING: Regex = Regex::new(r"\{\{(.*)\}\}").unwrap(); - static ref TEST_STRING: Regex = Regex::new(r"\{(.)").unwrap(); + pub static ref VAR_STRING: Regex = Regex::new(r"\{\{([\w--\d]\w*)\}\}").unwrap(); } fn variable_name(x: &str) -> Result<&str> { @@ -282,18 +303,14 @@ where match &self.0 { ValueEnum::Literal(_) => return Ok(()), ValueEnum::Variable(str) => { + // TODO: use `try_from` to extract name during parse time + // rather than expansion time let name = variable_name(&str)?; let value = match getter(name)? { Some(x) => x, None => return Ok(()), }; - self.0 = ValueEnum::Literal(As::::astype(&value).ok_or_else(|| { - Error::Constraint(format!( - "variable of type `{}`, found {}", - std::any::type_name::(), - value - )) - })?); + self.0 = ValueEnum::Literal(As::::astype(&value)?); return Ok(()); } }; @@ -303,7 +320,6 @@ where impl Merging for Value where toml::Value: As, - T: Copy, { fn coalesce(self, new: Self) -> Self { return new; @@ -316,7 +332,6 @@ where impl Value where - T: Copy, toml::Value: As, { pub fn unwrap(self) -> T { @@ -329,7 +344,6 @@ where impl Resolving for Value where - T: Copy, toml::Value: As, { fn resolve(self, name: impl Into) -> Result { From a8bb8edacb206c102cf7755860517931a826fbbd Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 16 Aug 2025 08:23:48 -0400 Subject: [PATCH 32/79] working `deinfe` tests Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 77 +++++++++++++------------ notes.md | 12 +++- src/rust/parsing/src/bind.rs | 4 +- src/rust/parsing/src/bind/validation.rs | 19 +++--- src/rust/parsing/src/define.rs | 35 +++++------ src/rust/parsing/src/error.rs | 2 +- src/rust/parsing/src/file.rs | 2 +- src/rust/parsing/src/scratch | 0 src/rust/parsing/src/util.rs | 18 +++++- src/rust/parsing/src/variable.rs | 2 +- 10 files changed, 94 insertions(+), 77 deletions(-) create mode 100644 src/rust/parsing/src/scratch diff --git a/.vscode/settings.json b/.vscode/settings.json index 94309f63..04d34c05 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#c82314", - "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#c82314", - "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#d53021", - "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#e23d2e", - "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#c82314", - "statusBar.foreground": "#ffffff", - "statusBar.border": "#c82314", - "statusBar.debuggingBackground": "#c82314", - "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#c82314", - "statusBar.noFolderBackground": "#c82314", - "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#c82314", - "statusBar.prominentBackground": "#c82314", - "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#c82314", - "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#c8231499", - "progressBar.background": "#c82314", - "textLink.foreground": "#ff6354", - "textLink.activeForeground": "#ff7061", - "selection.background": "#bb1607", - "list.highlightForeground": "#c82314", - "list.focusAndSelectionOutline": "#c8231499", - "button.background": "#c82314", - "button.foreground": "#ffffff", - "button.hoverBackground": "#d53021", - "tab.activeBorderTop": "#d53021", - "pickerGroup.foreground": "#d53021", - "list.activeSelectionBackground": "#c823144d", - "panelTitle.activeBorder": "#d53021", - "activityBar.activeBorder": "#c82314", - "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#c82314" + "statusBarItem.warningBackground": "#31f91f", + "statusBarItem.warningForeground": "#000000", + "statusBarItem.warningHoverBackground": "#31f91f", + "statusBarItem.warningHoverForeground": "#00000090", + "statusBarItem.remoteBackground": "#3eff2c", + "statusBarItem.remoteForeground": "#000000", + "statusBarItem.remoteHoverBackground": "#4bff39", + "statusBarItem.remoteHoverForeground": "#00000090", + "statusBar.background": "#31f91f", + "statusBar.foreground": "#000000", + "statusBar.border": "#31f91f", + "statusBar.debuggingBackground": "#31f91f", + "statusBar.debuggingForeground": "#000000", + "statusBar.debuggingBorder": "#31f91f", + "statusBar.noFolderBackground": "#31f91f", + "statusBar.noFolderForeground": "#000000", + "statusBar.noFolderBorder": "#31f91f", + "statusBar.prominentBackground": "#31f91f", + "statusBar.prominentForeground": "#000000", + "statusBar.prominentHoverBackground": "#31f91f", + "statusBar.prominentHoverForeground": "#00000090", + "focusBorder": "#31f91f99", + "progressBar.background": "#31f91f", + "textLink.foreground": "#71ff5f", + "textLink.activeForeground": "#7eff6c", + "selection.background": "#24ec12", + "list.highlightForeground": "#31f91f", + "list.focusAndSelectionOutline": "#31f91f99", + "button.background": "#31f91f", + "button.foreground": "#000000", + "button.hoverBackground": "#3eff2c", + "tab.activeBorderTop": "#3eff2c", + "pickerGroup.foreground": "#3eff2c", + "list.activeSelectionBackground": "#31f91f4d", + "panelTitle.activeBorder": "#3eff2c", + "activityBar.activeBorder": "#31f91f", + "activityBarBadge.foreground": "#000000", + "activityBarBadge.background": "#31f91f" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", @@ -65,4 +65,5 @@ "projectColors.isProjectNameColored": true, "projectColors.isActiveItemsColored": true, "projectColors.setWindowTitle": true, + "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.88.0-aarch64-apple-darwin", } diff --git a/notes.md b/notes.md index 942151d3..774c434c 100644 --- a/notes.md +++ b/notes.md @@ -93,14 +93,22 @@ Integration test debugging: - [X] problem: spannd doesn't work with flatten; we can solve this by creating an `id` field for `command` and `bind` that will throw an error if populatd when passed on to the non-input constructors - - [x] setup default keyword for `bind` + - [X] setup default keyword for `bind` - [ ] rework how `var.` works, resolving it at run time, not definition time - [~] unit tests for `define` parsing + - [X] rework `Required` so we get a meaningful error message + when the keybinding is wrong + - [ ] tests for `var` - [ ] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - - [ ] implement `default` keyword for `bind` + - [ ] implement `default` expansion for `bind` - [ ] get evaluation of computed elements working - [ ] use rhai to implement expression evaluation + - [ ] preparse all `{{}}` into + - [ ] parse time variables (for loop, `bind.` and `command.`) + - [ ] single variables references (no `rhai` required) + - [ ] actual expressions that are parsed into an AST by `rhai` - [ ] disable keywords/features that are for multiline or assignment + - [ ] include tests to prevent use of `command.` and `bind.` variables - [ ] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - [ ] implement support for tags on `bind` (for filter them) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index a9054274..016d496f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -876,8 +876,10 @@ mod tests { #[test] fn expand_foreach_keys() { + // TODO: error out if the regex inside of `{{}}` is not valid (right now it just + // fails silently) let data = r#" - foreach.key = ["{{key: [0-9]}}"] + foreach.key = ["{{key(`[0-9]`)}}"] name = "update {{key}}" command = "foo" args.value = "{{key}}" diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index abdd1d9a..c42d3be9 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -95,23 +95,23 @@ lazy_static! { ]; } -fn valid_key_binding_str(str: &str) -> bool { +fn valid_key_binding_str(str: &str) -> Result<()> { for press in Regex::new(r"\s+").unwrap().split(str) { let mut first = true; - for part in press.split('+') { + for part in press.split('+').rev() { if first { first = false; if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { - return false; + return Err(Error::Validation(format!("key name {part}")))?; } } else { if !MODIFIER_REGEX.is_match(part) { - return false; + return Err(Error::Validation(format!("modifier name {part}")))?; } } } } - return true; + return Ok(()); } #[derive(Serialize, Deserialize, Clone, Debug)] @@ -123,13 +123,8 @@ impl TryFrom for KeyBinding { fn try_from(value: String) -> Result { if VAR_STRING.is_match(&value) { return Ok(KeyBinding(ValueEnum::Variable(value))); - } else if !valid_key_binding_str(&value) { - return Err(crate::error::Error::Validation( - "keybinding; must be\ - a sequence of [mod]+[key] values (see \ - https://code.visualstudio.com/docs/getstarted/keybindings#_accepted-keys)", - ))?; } else { + valid_key_binding_str(&value)?; return Ok(KeyBinding(ValueEnum::Literal(value))); } } @@ -203,7 +198,7 @@ impl TryFrom for BindingReference { fn try_from(value: String) -> Result { let captures = BIND_STRING.captures(&value).ok_or_else(|| { crate::error::Error::Validation( - "binding reference; must be of the form `{{bind.[identifier]}})", + "binding reference; must be of the form `{{bind.[identifier]}})".into(), ) })?; let name = captures.get(1).expect("`bind.` identifier capture"); diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 3b58dc60..c5485559 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -6,6 +6,7 @@ use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, Resul use crate::util::Requiring; use crate::variable::VariableExpanding; +use indexmap::IndexMap; #[allow(unused_imports)] use log::info; use serde::{Deserialize, Serialize}; @@ -15,16 +16,11 @@ use wasm_bindgen::prelude::*; #[derive(Deserialize, Serialize, Clone, Debug)] pub struct DefineInput { - pub var: Option>>>, + pub var: Option>>>, pub command: Option>>, pub bind: Option>>, } -// TODO: resolve variables for each item in `DefineInput` until -// there are no variables left to resolve or we hit a limit -// NOTE: we might have to implement pruning to get this to -// run in a reasonable time - pub trait VariableResolver { fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()>; } @@ -69,10 +65,6 @@ impl Define { let mut resolved_var = HashMap::::new(); let mut errors = Vec::new(); - // TODO: we don't want to parse *expressions* that start with a reference to a var. - // command. or bind. (e.g. {{var.a + var.b}}) variable to be read as a variable - // reference here (also a good thing to writ ea test for down below) - // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they // must only reference previously defined variables (we've included the TOML feature // to preserve order, so variables can reference other variables defined within the @@ -381,6 +373,9 @@ mod tests { [[var]] b = "{{var.a}}-boot" + c = "bop-{{var.b}}" + d = "bop-{{var.e}}" + e = "fop" [[var]] c = "{{var.not_defined}}-boot" @@ -408,14 +403,14 @@ mod tests { args.value = "{{count}}" [[bind]] - default = "{{bind.horace}} - id = "bob + default = "{{bind.horace}}" + id = "bob" key = "ctrl+y" command = "cursorRight" [[bind]] - default = "{{bind.will}} - id = "bob + default = "{{bind.will}}" + id = "bob" key = "ctrl+k" command = "cursorDown" "#; @@ -428,22 +423,24 @@ mod tests { false }); assert!(if let Error::UndefinedVariable(ref str) = result[1].error { - str.starts_with("`var.not_defined`") + str.starts_with("`var.e`") } else { false }); assert!(if let Error::UndefinedVariable(ref str) = result[2].error { + str.starts_with("`var.not_defined`") + } else { + false + }); + assert!(if let Error::UndefinedVariable(ref str) = result[3].error { str.starts_with("`command.biz`") } else { false }); - assert!(if let Error::ForwardReference(ref str) = result[3].error { + assert!(if let Error::ForwardReference(ref str) = result[4].error { str.starts_with("`bind.horace`") } else { false }); } - - // - missing `var.`, `bind.` or `command.` values - // - bad order of values thereof } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index d6f099b4..e650d34c 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -16,7 +16,7 @@ pub enum Error { #[error("serializing {0}")] Serialization(#[from] toml::ser::Error), #[error("invalid {0}")] - Validation(&'static str), + Validation(String), #[error("expected {0}")] Constraint(String), #[error("requires {0}")] diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 2d2d913e..d1c8d319 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -104,7 +104,7 @@ mod tests { #[test] fn parse_example() { let data = r#" - [define.var] + [[define.var]] foo = "bar" [[bind]] diff --git a/src/rust/parsing/src/scratch b/src/rust/parsing/src/scratch new file mode 100644 index 00000000..e69de29b diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 56bc6eb3..c8b454e1 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,6 +1,6 @@ use crate::{ bind::UNKNOWN_RANGE, - error::{Error, ErrorContext, Result}, + error::{Error, ErrorContext, ErrorWithContext, Result}, }; use log::info; @@ -115,13 +115,26 @@ impl Requiring for Option { // required values are only required at the very end of parsing, once all known defaults // have been resolved #[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] -#[serde(untagged)] +#[serde(untagged, try_from = "Option")] pub enum Required { #[default] DefaultValue, Value(T), } +impl<'de, T> TryFrom> for Required +where + T: Deserialize<'de>, +{ + type Error = ErrorWithContext; + fn try_from(value: Option) -> Result { + match value { + None => Ok(Required::DefaultValue), + Some(x) => Ok(Required::Value(toml::Value::try_into(x)?)), + } + } +} + impl Required> { pub fn into_inner(self) -> Required { return match self { @@ -172,6 +185,7 @@ impl Required { } } +// TODO: use `try_from` to improve error messages #[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged)] pub enum Plural { diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index a0fb1438..b42e9e3a 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -273,7 +273,7 @@ where } lazy_static! { - pub static ref VAR_STRING: Regex = Regex::new(r"\{\{([\w--\d]\w*)\}\}").unwrap(); + pub static ref VAR_STRING: Regex = Regex::new(r"\{\{([\w--\d][\.\w]*)\}\}").unwrap(); } fn variable_name(x: &str) -> Result<&str> { From 8b1f2668789d87656be55f2bd28e3f20847ef72e Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 18 Aug 2025 00:05:35 -0400 Subject: [PATCH 33/79] plan for refactoring `define` expansion Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 76 ++++++++++++------------- notes.md | 11 ++-- src/rust/parsing/src/bind/validation.rs | 17 ++++-- src/rust/parsing/src/define.rs | 27 ++++----- src/rust/parsing/src/variable.rs | 18 +----- 5 files changed, 66 insertions(+), 83 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 04d34c05..3fcca893 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#31f91f", - "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#31f91f", - "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#3eff2c", - "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#4bff39", - "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#31f91f", - "statusBar.foreground": "#000000", - "statusBar.border": "#31f91f", - "statusBar.debuggingBackground": "#31f91f", - "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#31f91f", - "statusBar.noFolderBackground": "#31f91f", - "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#31f91f", - "statusBar.prominentBackground": "#31f91f", - "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#31f91f", - "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#31f91f99", - "progressBar.background": "#31f91f", - "textLink.foreground": "#71ff5f", - "textLink.activeForeground": "#7eff6c", - "selection.background": "#24ec12", - "list.highlightForeground": "#31f91f", - "list.focusAndSelectionOutline": "#31f91f99", - "button.background": "#31f91f", - "button.foreground": "#000000", - "button.hoverBackground": "#3eff2c", - "tab.activeBorderTop": "#3eff2c", - "pickerGroup.foreground": "#3eff2c", - "list.activeSelectionBackground": "#31f91f4d", - "panelTitle.activeBorder": "#3eff2c", - "activityBar.activeBorder": "#31f91f", - "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#31f91f" + "statusBarItem.warningBackground": "#301ce3", + "statusBarItem.warningForeground": "#ffffff", + "statusBarItem.warningHoverBackground": "#301ce3", + "statusBarItem.warningHoverForeground": "#ffffff90", + "statusBarItem.remoteBackground": "#3d29f0", + "statusBarItem.remoteForeground": "#ffffff", + "statusBarItem.remoteHoverBackground": "#4a36fd", + "statusBarItem.remoteHoverForeground": "#ffffff90", + "statusBar.background": "#301ce3", + "statusBar.foreground": "#ffffff", + "statusBar.border": "#301ce3", + "statusBar.debuggingBackground": "#301ce3", + "statusBar.debuggingForeground": "#ffffff", + "statusBar.debuggingBorder": "#301ce3", + "statusBar.noFolderBackground": "#301ce3", + "statusBar.noFolderForeground": "#ffffff", + "statusBar.noFolderBorder": "#301ce3", + "statusBar.prominentBackground": "#301ce3", + "statusBar.prominentForeground": "#ffffff", + "statusBar.prominentHoverBackground": "#301ce3", + "statusBar.prominentHoverForeground": "#ffffff90", + "focusBorder": "#301ce399", + "progressBar.background": "#301ce3", + "textLink.foreground": "#705cff", + "textLink.activeForeground": "#7d69ff", + "selection.background": "#230fd6", + "list.highlightForeground": "#301ce3", + "list.focusAndSelectionOutline": "#301ce399", + "button.background": "#301ce3", + "button.foreground": "#ffffff", + "button.hoverBackground": "#3d29f0", + "tab.activeBorderTop": "#3d29f0", + "pickerGroup.foreground": "#3d29f0", + "list.activeSelectionBackground": "#301ce34d", + "panelTitle.activeBorder": "#3d29f0", + "activityBar.activeBorder": "#301ce3", + "activityBarBadge.foreground": "#ffffff", + "activityBarBadge.background": "#301ce3" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/notes.md b/notes.md index 774c434c..3be13cb1 100644 --- a/notes.md +++ b/notes.md @@ -94,21 +94,22 @@ Integration test debugging: creating an `id` field for `command` and `bind` that will throw an error if populatd when passed on to the non-input constructors - [X] setup default keyword for `bind` - - [ ] rework how `var.` works, resolving it at run time, not definition time - - [~] unit tests for `define` parsing + - [X] rework how `var.` works, resolving it at run time, not definition time + - [X] unit tests for `define` parsing - [X] rework `Required` so we get a meaningful error message when the keybinding is wrong - - [ ] tests for `var` - - [ ] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - - [ ] implement `default` expansion for `bind` + - [X] tests for `var` - [ ] get evaluation of computed elements working - [ ] use rhai to implement expression evaluation - [ ] preparse all `{{}}` into - [ ] parse time variables (for loop, `bind.` and `command.`) + - [ ] interpolated string - [ ] single variables references (no `rhai` required) - [ ] actual expressions that are parsed into an AST by `rhai` - [ ] disable keywords/features that are for multiline or assignment - [ ] include tests to prevent use of `command.` and `bind.` variables + - [ ] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields + - [ ] implement `default` expansion for `bind` - [ ] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - [ ] implement support for tags on `bind` (for filter them) diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index c42d3be9..089bd5ba 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -121,11 +121,16 @@ pub struct KeyBinding(ValueEnum); impl TryFrom for KeyBinding { type Error = crate::error::ErrorWithContext; fn try_from(value: String) -> Result { - if VAR_STRING.is_match(&value) { - return Ok(KeyBinding(ValueEnum::Variable(value))); - } else { - valid_key_binding_str(&value)?; - return Ok(KeyBinding(ValueEnum::Literal(value))); + match BIND_STRING.captures(&value) { + Some(captures) => { + return Ok(KeyBinding(ValueEnum::Variable( + captures.get(1).expect("variable name").as_str().into(), + ))); + } + None => { + valid_key_binding_str(&value)?; + return Ok(KeyBinding(ValueEnum::Literal(value))); + } } } } @@ -134,7 +139,7 @@ impl From for String { fn from(value: KeyBinding) -> Self { match value.0 { ValueEnum::Literal(x) => x, - ValueEnum::Variable(x) => x, + ValueEnum::Variable(x) => format!("{}{x}{}", "{{", "}}"), } } } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index c5485559..586ccbe3 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -69,14 +69,16 @@ impl Define { // must only reference previously defined variables (we've included the TOML feature // to preserve order, so variables can reference other variables defined within the // same block) + + // TODO: do not resolve `var` values, and do not allow `{{}}` inside of `var.` values for def_block in input.var.into_iter().flatten() { for (var, mut value) in def_block.into_iter() { let mut var_result = value.expand_with_getter(|id| { if let Some((prefix, name)) = id.split_once('.') { if prefix == "var" { - let resolved = resolved_var.get(name). - ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; - return Ok(Some(resolved.clone())); + return Err(Error::Constraint( + "no references to `var` within a `var` definition".into() + ))?; } else if prefix == "bind" || prefix == "command" { return Err(Error::ForwardReference(format!( "`{id}`; you cannot refer to `{prefix}` values within `var` definitions" @@ -373,12 +375,6 @@ mod tests { [[var]] b = "{{var.a}}-boot" - c = "bop-{{var.b}}" - d = "bop-{{var.e}}" - e = "fop" - - [[var]] - c = "{{var.not_defined}}-boot" [[command]] id = "foo" @@ -422,25 +418,22 @@ mod tests { } else { false }); - assert!(if let Error::UndefinedVariable(ref str) = result[1].error { - str.starts_with("`var.e`") + assert!(if let Error::Constraint(ref str) = result[1].error { + str.starts_with("no references to `var`") } else { false }); assert!(if let Error::UndefinedVariable(ref str) = result[2].error { - str.starts_with("`var.not_defined`") - } else { - false - }); - assert!(if let Error::UndefinedVariable(ref str) = result[3].error { str.starts_with("`command.biz`") } else { false }); - assert!(if let Error::ForwardReference(ref str) = result[4].error { + assert!(if let Error::ForwardReference(ref str) = result[3].error { str.starts_with("`bind.horace`") } else { false }); + info!("result: {:#?}", result); + assert_eq!(result.len(), 4); } } diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index b42e9e3a..3552f6d6 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -276,21 +276,6 @@ lazy_static! { pub static ref VAR_STRING: Regex = Regex::new(r"\{\{([\w--\d][\.\w]*)\}\}").unwrap(); } -fn variable_name(x: &str) -> Result<&str> { - if VAR_STRING.captures(x).is_some_and(|c| c.len() == x.len()) { - return Ok(VAR_STRING - .captures(x) - .ok_or_else(|| Error::Constraint(r"string starts and ends with `{{` and `}}`".into()))? - .get(1) - .ok_or_else(|| Error::Unexpected("empty variable"))? - .as_str()); - } else { - return Err(Error::Constraint( - r"string starts and ends with `{{` and `}}`".into(), - ))?; - } -} - impl VariableExpanding for Value where toml::Value: As, @@ -302,10 +287,9 @@ where { match &self.0 { ValueEnum::Literal(_) => return Ok(()), - ValueEnum::Variable(str) => { + ValueEnum::Variable(name) => { // TODO: use `try_from` to extract name during parse time // rather than expansion time - let name = variable_name(&str)?; let value = match getter(name)? { Some(x) => x, None => return Ok(()), From 0013682c88316de55017b52267169a05eefb16de Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 21 Aug 2025 00:07:06 -0400 Subject: [PATCH 34/79] wip expression evaluation Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 76 +++--- src/rust/parsing/Cargo.lock | 241 +++++++++++++++++++ src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/src/error.rs | 21 +- src/rust/parsing/src/variable.rs | 400 ++++++++++++++++++++----------- 5 files changed, 555 insertions(+), 184 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 3fcca893..f0c3ef7a 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#301ce3", - "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#301ce3", - "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#3d29f0", - "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#4a36fd", - "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#301ce3", - "statusBar.foreground": "#ffffff", - "statusBar.border": "#301ce3", - "statusBar.debuggingBackground": "#301ce3", - "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#301ce3", - "statusBar.noFolderBackground": "#301ce3", - "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#301ce3", - "statusBar.prominentBackground": "#301ce3", - "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#301ce3", - "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#301ce399", - "progressBar.background": "#301ce3", - "textLink.foreground": "#705cff", - "textLink.activeForeground": "#7d69ff", - "selection.background": "#230fd6", - "list.highlightForeground": "#301ce3", - "list.focusAndSelectionOutline": "#301ce399", - "button.background": "#301ce3", - "button.foreground": "#ffffff", - "button.hoverBackground": "#3d29f0", - "tab.activeBorderTop": "#3d29f0", - "pickerGroup.foreground": "#3d29f0", - "list.activeSelectionBackground": "#301ce34d", - "panelTitle.activeBorder": "#3d29f0", - "activityBar.activeBorder": "#301ce3", - "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#301ce3" + "statusBarItem.warningBackground": "#d2a914", + "statusBarItem.warningForeground": "#000000", + "statusBarItem.warningHoverBackground": "#d2a914", + "statusBarItem.warningHoverForeground": "#00000090", + "statusBarItem.remoteBackground": "#dfb621", + "statusBarItem.remoteForeground": "#000000", + "statusBarItem.remoteHoverBackground": "#ecc32e", + "statusBarItem.remoteHoverForeground": "#00000090", + "statusBar.background": "#d2a914", + "statusBar.foreground": "#000000", + "statusBar.border": "#d2a914", + "statusBar.debuggingBackground": "#d2a914", + "statusBar.debuggingForeground": "#000000", + "statusBar.debuggingBorder": "#d2a914", + "statusBar.noFolderBackground": "#d2a914", + "statusBar.noFolderForeground": "#000000", + "statusBar.noFolderBorder": "#d2a914", + "statusBar.prominentBackground": "#d2a914", + "statusBar.prominentForeground": "#000000", + "statusBar.prominentHoverBackground": "#d2a914", + "statusBar.prominentHoverForeground": "#00000090", + "focusBorder": "#d2a91499", + "progressBar.background": "#d2a914", + "textLink.foreground": "#ffe954", + "textLink.activeForeground": "#fff661", + "selection.background": "#c59c07", + "list.highlightForeground": "#d2a914", + "list.focusAndSelectionOutline": "#d2a91499", + "button.background": "#d2a914", + "button.foreground": "#000000", + "button.hoverBackground": "#dfb621", + "tab.activeBorderTop": "#dfb621", + "pickerGroup.foreground": "#dfb621", + "list.activeSelectionBackground": "#d2a9144d", + "panelTitle.activeBorder": "#dfb621", + "activityBar.activeBorder": "#d2a914", + "activityBarBadge.foreground": "#000000", + "activityBarBadge.background": "#d2a914" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 31bf2132..bff600c6 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -2,6 +2,20 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "const-random", + "getrandom 0.3.3", + "once_cell", + "version_check", + "zerocopy", +] + [[package]] name = "aho-corasick" version = "1.1.3" @@ -61,6 +75,18 @@ dependencies = [ "windows-sys", ] +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "bitflags" +version = "2.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a65b545ab31d687cff52899d4890855fec459eb6afe0da6417b8a18da87aa29" + [[package]] name = "bumpalo" version = "3.19.0" @@ -79,6 +105,32 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" +[[package]] +name = "const-random" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359" +dependencies = [ + "const-random-macro", +] + +[[package]] +name = "const-random-macro" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e" +dependencies = [ + "getrandom 0.2.16", + "once_cell", + "tiny-keccak", +] + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + [[package]] name = "env_filter" version = "0.1.3" @@ -108,6 +160,31 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" +[[package]] +name = "getrandom" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasi 0.14.2+wasi-0.2.4", +] + [[package]] name = "hashbrown" version = "0.15.5" @@ -125,6 +202,18 @@ dependencies = [ "serde", ] +[[package]] +name = "instant" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "is_terminal_polyfill" version = "1.70.1" @@ -171,6 +260,12 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" +[[package]] +name = "libc" +version = "0.2.175" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543" + [[package]] name = "log" version = "0.4.27" @@ -202,11 +297,23 @@ dependencies = [ "winapi", ] +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + [[package]] name = "once_cell" version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +dependencies = [ + "portable-atomic", +] [[package]] name = "once_cell_polyfill" @@ -230,6 +337,7 @@ dependencies = [ "lazy_static", "log", "regex", + "rhai", "serde", "serde-wasm-bindgen", "string-offsets", @@ -278,6 +386,12 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + [[package]] name = "regex" version = "1.11.1" @@ -322,6 +436,35 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +[[package]] +name = "rhai" +version = "1.22.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2780e813b755850e50b178931aaf94ed24f6817f46aaaf5d21c13c12d939a249" +dependencies = [ + "ahash", + "bitflags", + "getrandom 0.2.16", + "instant", + "num-traits", + "once_cell", + "rhai_codegen", + "smallvec", + "smartstring", + "thin-vec", +] + +[[package]] +name = "rhai_codegen" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5a11a05ee1ce44058fa3d5961d05194fdbe3ad6b40f904af764d81b86450e6b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "rustversion" version = "1.0.22" @@ -377,6 +520,29 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "smartstring" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fb72c633efbaa2dd666986505016c32c3044395ceaf881518399d2f4127ee29" +dependencies = [ + "autocfg", + "static_assertions", + "version_check", +] + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + [[package]] name = "string-offsets" version = "0.2.0" @@ -419,6 +585,12 @@ dependencies = [ "syn", ] +[[package]] +name = "thin-vec" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "144f754d318415ac792f9d69fc87abbbfc043ce2ef041c60f16ad828f638717d" + [[package]] name = "thiserror" version = "2.0.14" @@ -448,6 +620,15 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + [[package]] name = "toml" version = "0.9.5" @@ -553,6 +734,27 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasi" +version = "0.14.2+wasi-0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3" +dependencies = [ + "wit-bindgen-rt", +] + [[package]] name = "wasm-bindgen" version = "0.2.100" @@ -611,6 +813,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "web-sys" +version = "0.3.77" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + [[package]] name = "winapi" version = "0.3.9" @@ -718,3 +930,32 @@ name = "winnow" version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3edebf492c8125044983378ecb5766203ad3b4c2f7a922bd7dd207f6d443e95" + +[[package]] +name = "wit-bindgen-rt" +version = "0.39.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1" +dependencies = [ + "bitflags", +] + +[[package]] +name = "zerocopy" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 7474b2d8..61fa6a2b 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -10,6 +10,7 @@ js-sys = "0.3.77" lazy_static = "1.5.0" log = { version = "0.4.27", features = ["release_max_level_error"] } regex = "1.11.1" +rhai = { version = "1.22.2", features = ["no_optimize", "no_module", "no_function", "no_closure", "no_custom_syntax", "wasm-bindgen"] } serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" string-offsets = { version = "0.2.0", features = ["wasm"] } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index e650d34c..9c3d6c8f 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,6 +1,7 @@ use crate::bind::UNKNOWN_RANGE; use core::ops::Range; +use rhai; use std::fmt; use string_offsets::{Pos, StringOffsets}; use thiserror::Error; @@ -11,8 +12,10 @@ use wasm_bindgen::prelude::*; #[derive(Debug, Error, Clone)] pub enum Error { - #[error("parsing {0}")] - Parsing(#[from] toml::de::Error), + #[error("toml parsing {0}")] + TomlParsing(#[from] toml::de::Error), + #[error("expression parsing {0}")] + ExpressionParsing(#[from] rhai::parser::ParseResult), #[error("serializing {0}")] Serialization(#[from] toml::ser::Error), #[error("invalid {0}")] @@ -108,6 +111,20 @@ pub struct ErrorReport { pub items: Vec, } +fn flatten_errors(errs: impl Iterator>) -> ResultVec { + let (results, errors) = errs.partition(Result::is_ok); + let flat_errs = errors + .into_iter() + .flat_map(|x| x.unwrap_err().into_iter()) + .collect::>(); + + if flat_errs.len() > 0 { + return Err(flat_errs); + } else { + return Ok(results.into_iter().any(|x| x.unwrap())); + } +} + #[wasm_bindgen] #[derive(Debug, Clone)] pub struct CharRange { diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs index 3552f6d6..d15bd2f1 100644 --- a/src/rust/parsing/src/variable.rs +++ b/src/rust/parsing/src/variable.rs @@ -1,121 +1,160 @@ +use std::error; + use crate::error::{Error, ErrorContexts, ErrorWithContext, Result, ResultVec}; use crate::util::{Merging, Plural, Required, Resolving}; +use js_sys::Boolean; #[allow(unused_imports)] use log::info; use lazy_static::lazy_static; use regex::Regex; +use rhai::{CustomType, Engine, AST}; use serde::{Deserialize, Serialize}; use toml::Spanned; -pub trait VariableExpanding { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone; - fn expand_value(&mut self, var: &str, value: &toml::Value) -> ResultVec<()> { - self.expand_with_getter(|e_var| { - if e_var == var { - Ok(Some(value.clone())) - } else { - Ok(None) - } - }) - } +// TODO: implement Expanding type + +pub enum ExpandResult { + Expanded(Value), + Deferred, } -impl VariableExpanding for Spanned { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { - return self - .get_mut() - .expand_with_getter(getter) - .context_range(&self.span()); +pub enum Interp { + Constant(String), + Expression(Expression), +} + +pub enum Value { + Number(f64), + String(String), + Boolean(bool), + Array(Vec), + Table(IndexMap), + Interp(Vec), + Expression(Expression), +} + +pub enum Expression { + Variable(String), + Statement(String), +} + +lazy_static! { + pub static ref IDENTIFIER_CHAIN: Regex = Regex::new(r"((\s*[\w--\d]\w*\.)*[\w--\d]\w*)\s*\}\}").unwrap(); + pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*)\}\}").unwrap(); +} + +impl TryFrom for Value { + type Error = Vec; + fn try_from(value: toml::Value) -> ResultVec { + return Ok(match value { + toml::Value::Boolean(x) => Value::Boolean(x), + toml::Value::Float(x) => Value::Number(x), + toml::Value::Integer(x) => Value::Number(x.try_into().context("{x} cannot be expressed as a 64-bit floating-point number.")?), + toml::Value::Datetime(x) => Value::String(x.into()), + toml::Value::String(x) => string_to_expression(x)?, + toml::Value::Array(toml_values) => { + let values = flatten_errors(toml_values.iter().map(|x| Value::new(x, engine, expressions)))?; + is_constant = values.all(|x| x.is_constant); + Value::Array(values) + } + toml::Value::Table(toml_kv) => { + let kv = flatten_errors(toml_kv.iter().map(|(k, v)| Ok((k, Value::new(v, engine, expressions)?))))?; + is_constant = kv.all(|(k,v)| v.is_constant); + Value::Table(IndexMap::new(kv)) + } + }); } } -impl VariableExpanding for Vec { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { - return flatten_errors( - self.iter_mut() - .map(|x| x.expand_with_getter(getter.clone())), - ); +impl Value { + fn expressions(self: Value, expressions: &mut Vec) { + match self { + Value::Expression(x) => expressions.push(x), + Value::Interp(interps) => iterps.for_each(|iterp| { + match inter { + Interp::Expression(x) => expressions.push(x), + _ => (), + } + }), + Value::Array(items) => items.iter().for_each(|item| item.expressions(expressions)), + Value::Table(kv) => kv.values().for_each(|val| val.expressions(expressions)), + _ => (), + } } } -fn flatten_errors(errs: impl Iterator>) -> ResultVec<()> { - let errors = errs.filter(|x| x.is_err()); - let flat_errs = errors - .into_iter() - .flat_map(|x| x.unwrap_err().into_iter()) - .collect::>(); +// TODO: function to extract expressions into a vector +// TODO: functions +// - by replacing all observations of a given expression +// - by checking names and resolving or erroring (e.g. for `bind.` and `command.`) +// - by running an expression engine for each expression +// TODO: function to translate resolved expressions into toml::Value and JSON - if flat_errs.len() > 0 { - return Err(flat_errs); - } else { - return Ok(()); +struct TypedValue { + value: Value +} + +impl TryInto for TypedValue { + type Error = Error; + fn try_into(self) -> Result { + return match self.value { + Value::Boolean(x) => Ok(x), + Expression(str, i) => Err(Error::Unresolved("expression")), + _ => Err(Error::Constraint("boolean value")) + } } } -impl VariableExpanding for Plural { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { - match self { - Plural::Zero => return Ok(()), - Plural::One(x) => return x.expand_with_getter(getter), - Plural::Many(items) => { - return flatten_errors( - items - .iter_mut() - .map(|v| v.expand_with_getter(getter.clone())), - ); - } +impl TryInto for TypedValue { + type Error = Error; + fn try_into(self) -> Result { + return match self.value { + Value::Number(x) => Ok(x), + Expression(str, i) => Err(Error::Unresolved("expression")), + _ => Err(Error::Constraint("number")) } } } -impl VariableExpanding for Required { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { - Ok(match self { - Required::DefaultValue => (), - Required::Value(x) => x.expand_with_getter(getter)?, - }) +impl TryInto for TypedValue { + type Error = Error; + fn try_into(self) -> Result { + return match self.value { + Value::String(x) => Ok(x), + Expression(str, i) => Err(Error::Unresolved("expression")), + _ => Err(Error::Constraint("string")) + } } } -impl VariableExpanding for toml::map::Map { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { - let mut errors = Vec::new(); - let keys: Vec = self.keys().map(String::clone).collect(); - for k in keys { - match expand_to_value(&mut self[&k], getter.clone()) { - Err(ref mut err) => { - errors.append(err); - } - Ok(value) => { - self.insert(k.clone(), value); +// impl TryInto for TypedValue +// where T: Deserialize, +// { +// type Error = Error; +// fn try_into(self) -> Result { +// let toml = toml::Value::try_from(self)?; +// let val = Value::new() +// } +// } + +fn expand_variables(expander: F, expressions: &mut Vec) -> ResultVec<()> + where F: FnMut(&str) -> Result { + let errors = Vec::new(); + for i in 0..expressions.len() { + match expressions[i] { + Expression::Variable(str) => { + match expander(str) { + Err(e) => errors.push(e), + Ok(result) => if ExpandResult::Expanded(val) = result { + expressions[i] = Expression::Literal(val) + } } } + _ => () } + if errors.len() > 0 { return Err(errors); } else { @@ -124,42 +163,123 @@ impl VariableExpanding for toml::map::Map { } } -fn expand_to_value(value: &mut toml::Value, getter: F) -> ResultVec -where - F: Fn(&str) -> Result>, - F: Clone, -{ - match value { - toml::Value::String(str) => { - let captures = VAR_STRING.captures(str); - if let Some(c) = captures { - if c.get(0).unwrap().len() == str.len() { - let var = c.get(1).expect("variable capture group").as_str(); - let expanded = getter(var)?.unwrap_or_else(|| value.clone()); - return Ok(expanded); - } - } +impl Expression { + fn new(expr: &str) -> Result { + // XXX: array indices are more fragile to mutation; for now this seems okay + // but I could also see using a hash of the expression string to index + if IDENTIFIER_CHAIN.is_match(expr) { + return Expression::Variable(expr_str); + } else { + return Expression::Statement(expr_str); + } + } +} + +fn string_to_expression( + x: String, +) -> Value { + let exprs = EXPRESSION.captures_iter(x); + if exprs.first().get(0).expect("full_match").len() == x.len() { + return Value::Expression(Expression::new(exprs.first().get(1).expect("expression body").as_str())); + } else { // there are multiple expressions interpolated into the string + let mut interps = Vec::new(); + let mut last_match = 0..0; + for expr in exprs { + let r = expr.get(0).expect("full match").range(); + interps.push(InterpItem::Constant(&self[last_match.end..r.start])); + last_match = r; - str.expand_with_getter(getter)?; - return Ok(value.clone()); + let var_str = expr.get(1).expect("variable name").as_str(); + interps.push(InterpItem::Expression(Expression::new(var_str))); } - _ => { - value.expand_with_getter(getter)?; - return Ok(value.clone()); + if last_match.start == 0 && last_match.end == 0 { + return (true, Value::String(x)); } + if last_match.end < self.len() { + interps.push(InterpItem::Constant(&self[last_match.end..])); + } + return Value::Interp(interps); } } -impl VariableExpanding for toml::Value { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { +// TODO: implement methods to serialize to the values to json objects / toml values + +// TODO: `expand_with_getter` API isn't going to work +// since Rhai expects a scope object with all defined objects + +pub trait Expanding { + fn expand(&mut self, context: &impl Index) -> ResultVec; + fn expand_value(&mut self, var: &str, value: &Value) -> ResultVec<()> { + self.expand([(var, value)]); + } +} + +impl Expanding for Spanned { + fn expand(&mut self, context: &impl Index) -> ResultVec { + return self .get_mut().expand(context).context_range(&self.span()); + } +} + +impl Expanding for Vec { + fn expand(&mut self, context: &impl Index) -> ResultVec { + return flatten_errors(self.iter_mut().map(|x| x.expand(context))); + } +} + +impl Expanding for Plural { + fn expand(&mut self, context: &impl Index) -> ResultVec { match self { - toml::Value::String(x) => { - x.expand_with_getter(getter)?; - return Ok(()); + Plural::Zero => return Ok(true), + Plural::One(x) => return x.expand(context), + Plural::Many(items) => { + return flatten_errors( + items + .iter_mut() + .map(|v| v.expand(context)), + ); + } + } + } +} + +impl Expanding for Required { + fn expand(&mut self, context: &impl Index) -> ResultVec { + Ok(match self { + Required::DefaultValue => true, + Required::Value(x) => x.expand(context)?, + }) + } +} + +impl Expanding for IndexMap { + fn expand(&mut self, context: &impl Index) -> ResultVec { + return flatten_errors( + self.values_mut() + .map(|x| x.expand(context)), + ); + } +} + +impl Expanding for Value { + fn expand(&mut self, context: &impl Index) -> ResultVec { + if self.is_constant { + return Ok(()); + } + let (expansion, is_now_constant) = match self.data { + Value::Number(_) | Value::String(_) | Value::Boolean(_) => (self.data, true), + Value::Array(ref mut items) => (self.data, items.expand(context)), + Value::Table(ref mut kv) => (self.data, kv.expand(context)), + // TODO: we need to think on this more since we want to error + // or differ expansion depending on the name, so the context + // API doesn't quite work + Value::Variable(name) => match context[&name] { + ExpandResult::Deferred => (self.data, false), + ExpandResult::Expanded(val) => (val, false), + }, + Value::StringInterp(vals) => (self.data, vals.expand(context)), + Value::Expression(ast) => match expand_expression(ast, context) { + ExpandResult::Deferred => (self.data, false), + ExpandResult::Expanded() } toml::Value::Array(items) => { let mut errors = Vec::::new(); @@ -180,7 +300,7 @@ impl VariableExpanding for toml::Value { } } toml::Value::Table(kv) => { - return kv.expand_with_getter(getter); + return kv.expand(context); } toml::Value::Boolean(_) | toml::Value::Datetime(_) => return Ok(()), toml::Value::Float(_) | toml::Value::Integer(_) => return Ok(()), @@ -188,10 +308,10 @@ impl VariableExpanding for toml::Value { } } -impl VariableExpanding for Option { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> +impl Expanding for Option { + fn expand_with_getter(&mut self, getter: F) -> ResultVec where - F: Fn(&str) -> Result>, + F: Fn(&str) -> Result, F: Clone, { Ok(match self { @@ -249,13 +369,13 @@ where #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] #[serde(transparent)] -pub struct Value(ValueEnum) +pub struct TypedValue(TypedValueEnum) where toml::Value: As; #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] #[serde(untagged)] -pub enum ValueEnum +pub enum TypedValueEnum where toml::Value: As, { @@ -263,45 +383,37 @@ where Variable(String), } -impl Value +impl TypedValue where - toml::Value: As, + toml::TypedValue: As, { pub fn var(x: String) -> Self { - return Value(ValueEnum::Variable(x)); + return TypedValue(TypedValueEnum::Variable(x)); } } -lazy_static! { - pub static ref VAR_STRING: Regex = Regex::new(r"\{\{([\w--\d][\.\w]*)\}\}").unwrap(); -} - -impl VariableExpanding for Value +impl Expanding for TypedValue where toml::Value: As, { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> - where - F: Fn(&str) -> Result>, - F: Clone, - { + fn expand(&mut self, context: &impl Index) -> ResultVec { match &self.0 { - ValueEnum::Literal(_) => return Ok(()), - ValueEnum::Variable(name) => { + TypedValueEnum::Literal(_) => return Ok(()), + TypedValueEnum::Variable(name) => { // TODO: use `try_from` to extract name during parse time // rather than expansion time let value = match getter(name)? { Some(x) => x, None => return Ok(()), }; - self.0 = ValueEnum::Literal(As::::astype(&value)?); + self.0 = TypedValueEnum::Literal(As::::astype(&value)?); return Ok(()); } }; } } -impl Merging for Value +impl Merging for TypeValue where toml::Value: As, { @@ -314,7 +426,7 @@ where } } -impl Value +impl TypedValue where toml::Value: As, { @@ -326,24 +438,24 @@ where } } -impl Resolving for Value +impl Resolving for TypedValue where toml::Value: As, { fn resolve(self, name: impl Into) -> Result { return match self.0 { - ValueEnum::Literal(x) => Ok(x), - ValueEnum::Variable(str) => { + TypedValueEnum::Literal(x) => Ok(x), + TypedValueEnum::Variable(str) => { Err(Error::Unresolved(format!("{str} for {}", name.into())))? } }; } } -impl VariableExpanding for String { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> +impl Expanding for String { + fn expand_with_getter(&mut self, getter: F) -> ResultVec where - F: Fn(&str) -> Result>, + F: Fn(&str) -> Result, F: Clone, { let mut result = String::new(); From e0ba618a5d2917fcaa09e6dc9dedafd04b76caad Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 30 Aug 2025 14:52:44 -0400 Subject: [PATCH 35/79] `bind` tests working again Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 79 ++- mise.toml | 2 +- notes.md | 14 +- src/presets/larkin.toml | 15 +- src/rust/parsing/Cargo.lock | 91 +++ src/rust/parsing/Cargo.toml | 13 +- src/rust/parsing/errors.txt | 5 + src/rust/parsing/log.txt | 96 +++ src/rust/parsing/output.txt | 2 + src/rust/parsing/src/bind.rs | 809 +++++++++++++--------- src/rust/parsing/src/bind/foreach.rs | 59 +- src/rust/parsing/src/bind/validation.rs | 151 ++-- src/rust/parsing/src/define.rs | 880 ++++++++++++------------ src/rust/parsing/src/error.rs | 92 +-- src/rust/parsing/src/file.rs | 244 +++---- src/rust/parsing/src/lib.rs | 2 +- src/rust/parsing/src/util.rs | 32 +- src/rust/parsing/src/value.rs | 449 ++++++++++++ src/rust/parsing/src/variable.rs | 495 ------------- 19 files changed, 1959 insertions(+), 1571 deletions(-) create mode 100644 src/rust/parsing/errors.txt create mode 100644 src/rust/parsing/log.txt create mode 100644 src/rust/parsing/output.txt create mode 100644 src/rust/parsing/src/value.rs delete mode 100644 src/rust/parsing/src/variable.rs diff --git a/.vscode/settings.json b/.vscode/settings.json index f0c3ef7a..30688462 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#d2a914", - "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#d2a914", - "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#dfb621", - "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#ecc32e", - "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#d2a914", - "statusBar.foreground": "#000000", - "statusBar.border": "#d2a914", - "statusBar.debuggingBackground": "#d2a914", - "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#d2a914", - "statusBar.noFolderBackground": "#d2a914", - "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#d2a914", - "statusBar.prominentBackground": "#d2a914", - "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#d2a914", - "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#d2a91499", - "progressBar.background": "#d2a914", - "textLink.foreground": "#ffe954", - "textLink.activeForeground": "#fff661", - "selection.background": "#c59c07", - "list.highlightForeground": "#d2a914", - "list.focusAndSelectionOutline": "#d2a91499", - "button.background": "#d2a914", - "button.foreground": "#000000", - "button.hoverBackground": "#dfb621", - "tab.activeBorderTop": "#dfb621", - "pickerGroup.foreground": "#dfb621", - "list.activeSelectionBackground": "#d2a9144d", - "panelTitle.activeBorder": "#dfb621", - "activityBar.activeBorder": "#d2a914", - "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#d2a914" + "statusBarItem.warningBackground": "#ee2fcb", + "statusBarItem.warningForeground": "#ffffff", + "statusBarItem.warningHoverBackground": "#ee2fcb", + "statusBarItem.warningHoverForeground": "#ffffff90", + "statusBarItem.remoteBackground": "#fb3cd8", + "statusBarItem.remoteForeground": "#ffffff", + "statusBarItem.remoteHoverBackground": "#ff49e5", + "statusBarItem.remoteHoverForeground": "#ffffff90", + "statusBar.background": "#ee2fcb", + "statusBar.foreground": "#ffffff", + "statusBar.border": "#ee2fcb", + "statusBar.debuggingBackground": "#ee2fcb", + "statusBar.debuggingForeground": "#ffffff", + "statusBar.debuggingBorder": "#ee2fcb", + "statusBar.noFolderBackground": "#ee2fcb", + "statusBar.noFolderForeground": "#ffffff", + "statusBar.noFolderBorder": "#ee2fcb", + "statusBar.prominentBackground": "#ee2fcb", + "statusBar.prominentForeground": "#ffffff", + "statusBar.prominentHoverBackground": "#ee2fcb", + "statusBar.prominentHoverForeground": "#ffffff90", + "focusBorder": "#ee2fcb99", + "progressBar.background": "#ee2fcb", + "textLink.foreground": "#ff6fff", + "textLink.activeForeground": "#ff7cff", + "selection.background": "#e122be", + "list.highlightForeground": "#ee2fcb", + "list.focusAndSelectionOutline": "#ee2fcb99", + "button.background": "#ee2fcb", + "button.foreground": "#ffffff", + "button.hoverBackground": "#fb3cd8", + "tab.activeBorderTop": "#fb3cd8", + "pickerGroup.foreground": "#fb3cd8", + "list.activeSelectionBackground": "#ee2fcb4d", + "panelTitle.activeBorder": "#fb3cd8", + "activityBar.activeBorder": "#ee2fcb", + "activityBarBadge.foreground": "#ffffff", + "activityBarBadge.background": "#ee2fcb" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", @@ -66,4 +66,7 @@ "projectColors.isActiveItemsColored": true, "projectColors.setWindowTitle": true, "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.88.0-aarch64-apple-darwin", + "rust-analyzer.checkOnSave": true, + "rust-analyzer.cargo.allTargets": false, + "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, } diff --git a/mise.toml b/mise.toml index d97b8ae7..6550e87f 100644 --- a/mise.toml +++ b/mise.toml @@ -56,7 +56,7 @@ def main [...args] { get filenames.0 | each { |f| $'--object=($in)' } - cargo +nightly test --tests ...$args -- --nocapture + cargo +nightly test --target wasm32-unknown-unknown --tests ...$args -- --nocapture cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> ../../../coverage/rs_coverage.info) diff --git a/notes.md b/notes.md index 3be13cb1..880f6cf4 100644 --- a/notes.md +++ b/notes.md @@ -89,16 +89,16 @@ Integration test debugging: - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] expansion of `[define]` sections - - [X] implement support for resolving `var.`, `command.` and `bind.` definitions - - [X] problem: spannd doesn't work with flatten; we can solve this by + - [ ] implement support for resolving `var.`, `command.` and `bind.` definitions + - [ ] problem: spannd doesn't work with flatten; we can solve this by creating an `id` field for `command` and `bind` that will throw an error if populatd when passed on to the non-input constructors - - [X] setup default keyword for `bind` - - [X] rework how `var.` works, resolving it at run time, not definition time - - [X] unit tests for `define` parsing - - [X] rework `Required` so we get a meaningful error message + - [ ] setup default keyword for `bind` + - [ ] rework how `var.` works, resolving it at run time, not definition time + - [ ] unit tests for `define` parsing + - [ ] rework `Required` so we get a meaningful error message when the keybinding is wrong - - [X] tests for `var` + - [ ] tests for `var` - [ ] get evaluation of computed elements working - [ ] use rhai to implement expression evaluation - [ ] preparse all `{{}}` into diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index e44b6ff7..42de6dbc 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -184,11 +184,9 @@ prefixes = "{{all_prefixes}}" default = "{{bind.modes}}" name = "ignore" description = "this key does nothing" -foreach.key = [ - '{{key(`.`)}}', - 'shift+{{key(`.`)}}', -] #- all keys whose bindings are described by a single character -key = "{{key}}" +foreach.key = ["{{keys(`.`}}"] +foreach.modifier = ["shift+", ""] +key = "{{modifier}}{{key}}" command = "master-key.ignore" prefixes = "{{all_prefixes}}" mode = ["normal", "selectedit"] @@ -629,7 +627,7 @@ args.boundary = "both" # times e.g. 2w would select the next two words starting from the current cursor position. [[bind]] -foreach.num = ['{{key(`[0-9]`)}}'] +foreach.num = ['{{keys(`[0-9]`)}}'] name = "count {{num}}" key = "{{num}}" command = "master-key.updateCount" @@ -3320,10 +3318,11 @@ mode = "syminsert" [[bind]] default = "{{bind.edit_action_symmetric}}" -foreach.key = ["{{key(`[a-z]`)}}", "shift+{{key(`[a-z]`)}}"] +foreach.key = ["{{keys(`[a-z]`)}}"] +foreach.modifier = ["shift+", ""] name = "" description = "this key is ignored and has no associated command in syminsert mode" -key = "{{key}}" +key = "{{modifier}}{{key}}" command = "master-key.ignore" mode = "syminsert" hideInDocs = true diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index bff600c6..10877aed 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -93,6 +93,15 @@ version = "3.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43" +[[package]] +name = "cc" +version = "1.2.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42bc4aea80032b7bf409b0bc7ccad88853858911b7713a8062fdc0623867bedc" +dependencies = [ + "shlex", +] + [[package]] name = "cfg-if" version = "1.0.1" @@ -287,6 +296,16 @@ version = "2.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0" +[[package]] +name = "minicov" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f27fe9f1cc3c22e1687f9446c2083c4c5fc7f0bcf1c7a86bdbded14985895b4b" +dependencies = [ + "cc", + "walkdir", +] + [[package]] name = "nu-ansi-term" version = "0.46.0" @@ -345,6 +364,7 @@ dependencies = [ "thiserror", "toml", "wasm-bindgen", + "wasm-bindgen-test", ] [[package]] @@ -471,6 +491,15 @@ version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + [[package]] name = "serde" version = "1.0.219" @@ -520,6 +549,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + [[package]] name = "smallvec" version = "1.15.1" @@ -740,6 +775,16 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + [[package]] name = "wasi" version = "0.11.1+wasi-snapshot-preview1" @@ -781,6 +826,19 @@ dependencies = [ "wasm-bindgen-shared", ] +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61" +dependencies = [ + "cfg-if", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + [[package]] name = "wasm-bindgen-macro" version = "0.2.100" @@ -813,6 +871,30 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wasm-bindgen-test" +version = "0.3.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66c8d5e33ca3b6d9fa3b4676d774c5778031d27a578c2b007f905acf816152c3" +dependencies = [ + "js-sys", + "minicov", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test-macro", +] + +[[package]] +name = "wasm-bindgen-test-macro" +version = "0.3.50" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17d5042cc5fa009658f9a7333ef24291b1291a25b6382dd68862a7f3b969f69b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "web-sys" version = "0.3.77" @@ -839,6 +921,15 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" +[[package]] +name = "winapi-util" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0978bf7171b3d90bac376700cb56d606feb40f251a475a5d6634613564460b22" +dependencies = [ + "windows-sys", +] + [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 61fa6a2b..8798b49f 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -10,7 +10,14 @@ js-sys = "0.3.77" lazy_static = "1.5.0" log = { version = "0.4.27", features = ["release_max_level_error"] } regex = "1.11.1" -rhai = { version = "1.22.2", features = ["no_optimize", "no_module", "no_function", "no_closure", "no_custom_syntax", "wasm-bindgen"] } +rhai = { version = "1.22.2", default-features = false, features = [ + "no_optimize", + "no_module", + "no_function", + "no_closure", + "no_custom_syntax", + "std", +] } serde = { version = "1.0.219", features = ["derive"] } serde-wasm-bindgen = "0.6.5" string-offsets = { version = "0.2.0", features = ["wasm"] } @@ -18,6 +25,10 @@ test-log = "0.2.18" thiserror = "2.0.12" toml = { version = "0.9.2", features = ["preserve_order"] } wasm-bindgen = "0.2.100" +wasm-bindgen-test = "0.3.50" [lib] crate-type = ["cdylib"] + +[target.'cfg(target_arch="wasm")'.dependencies] +rhai = { version = "1.22.2", features = ["wasm-bindgen"] } diff --git a/src/rust/parsing/errors.txt b/src/rust/parsing/errors.txt new file mode 100644 index 00000000..50382150 --- /dev/null +++ b/src/rust/parsing/errors.txt @@ -0,0 +1,5 @@ + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s + diff --git a/src/rust/parsing/log.txt b/src/rust/parsing/log.txt new file mode 100644 index 00000000..267bd161 --- /dev/null +++ b/src/rust/parsing/log.txt @@ -0,0 +1,96 @@ + +running 1 test +Testing +Trying to convert from toml to TypedValue String("do") +parsed value +Constant! +read as toml! +result: Ok("do") +converted! +Trying to convert from toml to TypedValue String("joe > 1") +parsed value +Constant! +read as toml! +result: Ok("joe > 1") +converted! +Trying to convert from toml to TypedValue String("normal") +parsed value +Constant! +read as toml! +result: Ok("normal") +converted! +Trying to convert from toml to TypedValue Integer(1) +parsed value +Constant! +read as toml! +result: Ok(1.0) +converted! +Trying to convert from toml to TypedValue String("c") +parsed value +Constant! +read as toml! +result: Ok("c") +converted! +Trying to convert from toml to TypedValue Boolean(true) +parsed value +Constant! +read as toml! +result: Ok(true) +converted! +Trying to convert from toml to TypedValue String("{{2+c}}") +parsed value +parsing::error::Error: Into -> ErrorWithContext +ErrorWithContext -> ErrorsWithContext +Variable! +Trying to convert from toml to TypedValue String("foo") +parsed value +Constant! +read as toml! +result: Ok("foo") +converted! +Trying to convert from toml to TypedValue String("foo bar bin") +parsed value +Constant! +read as toml! +result: Ok("foo bar bin") +converted! +Trying to convert from toml to TypedValue Boolean(false) +parsed value +Constant! +read as toml! +result: Ok(false) +converted! +Trying to convert from toml to TypedValue Boolean(false) +parsed value +Constant! +read as toml! +result: Ok(false) +converted! +Trying to convert from toml to TypedValue String("Up/down") +parsed value +Constant! +read as toml! +result: Ok("Up/down") +converted! +Trying to convert from toml to TypedValue String("A/B") +parsed value +Constant! +read as toml! +result: Ok("A/B") +converted! +Trying to convert from toml to TypedValue String("bla bla bla") +parsed value +Constant! +read as toml! +result: Ok("bla bla bla") +converted! +Trying to convert from toml to TypedValue String("biz") +parsed value +Constant! +read as toml! +result: Ok("biz") +converted! +test bind::tests::complete_parsing ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.04s + diff --git a/src/rust/parsing/output.txt b/src/rust/parsing/output.txt new file mode 100644 index 00000000..d12fa15c --- /dev/null +++ b/src/rust/parsing/output.txt @@ -0,0 +1,2 @@ + +running 1 test diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 016d496f..ea5755d6 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -2,32 +2,39 @@ #![allow(non_snake_case)] -mod foreach; -mod validation; - -use crate::bind::foreach::expand_keys; -use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{ - ErrorContext, ErrorContexts, Result, ResultVec, constrain, reserved, unexpected, -}; -use crate::util::{Merging, Plural, Required, Requiring, Resolving}; -use crate::variable; -use crate::variable::VariableExpanding; - #[allow(unused_imports)] use log::info; +use std::convert::identity; + +use std::collections::VecDeque; +use std::error; + use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; -use toml::{Spanned, Value}; +use std::io; +use toml::Spanned; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; +mod foreach; +mod validation; + +use crate::bind::foreach::expand_keys; +use crate::bind::validation::{BindingReference, KeyBinding}; +use crate::error::ErrorsWithContext; +use crate::error::{Error, ErrorContext, Result, ResultVec, constrain, reserved, unexpected}; +use crate::util::{Merging, Plural, Required, Requiring, Resolving}; +use crate::value::{Expanding, TypedValue, Value}; + pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; -fn default_mode() -> Spanned> { - return Spanned::new(UNKNOWN_RANGE, Plural::One("default".into())); +fn default_mode() -> Spanned>> { + return Spanned::new( + UNKNOWN_RANGE, + Plural::One(TypedValue::Constant("default".into())), + ); } fn span_required_default() -> Spanned> { @@ -58,7 +65,7 @@ fn span_plural_default() -> Spanned> { * a `*`. * */ -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Clone, Debug)] pub struct BindingInput { // should only be `Some` in context of `Define(Input)` pub(crate) id: Option>, @@ -72,7 +79,7 @@ pub struct BindingInput { * (see [running multiple commands](#running-multiple-commands)). */ #[serde(default = "span_required_default")] - pub command: Spanned>, + pub command: Spanned>>, /** * @forBindingField bind @@ -81,7 +88,7 @@ pub struct BindingInput { * values. */ #[serde(default)] - pub args: Option>, + pub args: Option>, /** * @forBindingField bind @@ -100,18 +107,17 @@ pub struct BindingInput { * context under which the binding will be active. Also see Master Key's * [available contexts](#available-contexts) */ - #[serde(default = "span_plural_default")] - pub when: Spanned>, + pub when: Option>>, /** * @forBindingField bind * * - `mode`: The mode during which the binding will be active. The default mode is * used when this field is not specified (either directly or via the `defaults` * field). You can also specify multiple modes as an array of strings. To specify - * a binding that is applied in all modes use "{{all_modes}}". + * a binding that is applied in all modes use "{{all_modes()}}". */ #[serde(default = "default_mode")] - pub mode: Spanned>, + pub mode: Spanned>>, /** * @forBindingField bind * @@ -119,7 +125,7 @@ pub struct BindingInput { * bindings take precedence. Defaults to 0. */ #[serde(default)] - pub priority: Option>>, + pub priority: Option>>, /** * @forBindingField bind * @@ -136,7 +142,7 @@ pub struct BindingInput { * [`foreach` clauses](#foreach-clauses). */ #[serde(default)] - pub foreach: Option>>>, + pub foreach: Option>>>, /** * @forBindingField bind @@ -151,7 +157,7 @@ pub struct BindingInput { * in Larkin). */ #[serde(default = "span_plural_default")] - pub prefixes: Spanned>, + pub prefixes: Spanned>>, /** * @forBindingField bind @@ -161,7 +167,7 @@ pub struct BindingInput { * [`master-key.prefix`](/commands/prefix) for details. */ #[serde(default)] - pub finalKey: Option>>, + pub finalKey: Option>>, /** * @forBindingField bind @@ -174,7 +180,7 @@ pub struct BindingInput { * - `command` will be repeated the given * number of times. */ - repeat: Option>, + repeat: Option>>, /** * @forBindingField bind @@ -190,7 +196,7 @@ pub struct BindingInput { * keys. Favor unicode symbols such as → and ← over text. */ #[serde(default)] - pub name: Option>, + pub name: Option>>, /** * @forBindingField bind @@ -201,7 +207,7 @@ pub struct BindingInput { * for the literate comments. */ #[serde(default)] - pub description: Option>, + pub description: Option>>, /** * @forBindingField bind * @order 10 @@ -210,9 +216,9 @@ pub struct BindingInput { * and the documentation. These both default to false. */ #[serde(default)] - pub hideInPalette: Option>>, + pub hideInPalette: Option>>, #[serde(default)] - pub hideInDocs: Option>>, + pub hideInDocs: Option>>, /** * @forBindingField bind @@ -226,11 +232,11 @@ pub struct BindingInput { * `combinedDescription` are ignored. */ #[serde(default)] - pub combinedName: Option>, + pub combinedName: Option>>, #[serde(default)] - pub combinedKey: Option>, + pub combinedKey: Option>>, #[serde(default)] - pub combinedDescription: Option>, + pub combinedDescription: Option>>, /** * @forBindingField bind @@ -241,7 +247,7 @@ pub struct BindingInput { * entry in the top-level `kind` array. */ #[serde(default)] - pub kind: Option>, + pub kind: Option>>, } impl BindingInput { @@ -281,6 +287,7 @@ impl Merging for BindingInput { command: self.command.coalesce(y.command), args: self.args.merge(y.args), key: self.key.coalesce(y.key), + kind: self.kind.coalesce(y.kind), when: self.when.coalesce(y.when), mode: self.mode.coalesce(y.mode), priority: self.priority.coalesce(y.priority), @@ -296,34 +303,49 @@ impl Merging for BindingInput { combinedName: self.combinedName.coalesce(y.combinedName), combinedKey: self.combinedKey.coalesce(y.combinedKey), combinedDescription: self.combinedDescription.coalesce(y.combinedDescription), - kind: self.kind.coalesce(y.kind), } } } -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Deserialize, Clone, Debug)] pub struct CommandInput { // should only be `Some` in context of `Define(Input)` - pub(crate) id: Option>, - pub command: Spanned>, - pub args: Option>, + pub(crate) id: Option>>, + pub command: Spanned>>, + pub args: Option>, } -impl VariableExpanding for CommandInput { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> +impl Expanding for CommandInput { + fn is_constant(&self) -> bool { + if self.command.is_constant() { + return false; + } + if self.args.is_constant() { + return false; + } + return true; + } + fn map_expressions(self, f: &F) -> ResultVec where - F: Fn(&str) -> Result>, - F: Clone, + F: Fn(String) -> Result, { - self.command - .expand_with_getter(getter.clone()) - .context_str("`command` field") - .context_range(&self.command)?; - self.args - .expand_with_getter(getter.clone()) - .context_str("`args` field") - .context_range(&self.args)?; - return Ok(()); + let mut errors = Vec::new(); + let result = CommandInput { + id: self.id, + command: self.command.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) + }), + args: self.args.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + }; + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } } } @@ -340,12 +362,16 @@ impl CommandInput { #[wasm_bindgen(getter_with_clone)] #[derive(Clone, Debug, Serialize)] pub struct Command { - pub command: String, - pub(crate) args: toml::Table, + pub(crate) command: TypedValue, + pub(crate) args: Value, } +// TODO: here is where we would want to invoke rhai to resolve any outstanding expressions #[wasm_bindgen] impl Command { + pub fn command(&self) -> std::result::Result { + return Ok("TODO".into()); + } #[wasm_bindgen(getter)] pub fn args(&self) -> std::result::Result { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); @@ -362,7 +388,7 @@ impl Command { command: input.command.into_inner().resolve("`command` field")?, args: match input.args { Some(x) => x.into_inner(), - None => toml::Table::new(), + None => Value::Table(IndexMap::new()), }, }); } @@ -380,7 +406,7 @@ pub struct Binding { pub priority: i64, pub prefixes: Vec, pub finalKey: bool, - pub repeat: Option, + pub(crate) repeat: Option>, pub name: Option, pub description: Option, pub hideInPalette: bool, @@ -391,6 +417,13 @@ pub struct Binding { pub kind: Option, } +#[wasm_bindgen] +impl Binding { + pub fn repeat_count(&self) -> std::result::Result { + return Ok("TODO".into()); + } +} + // TODO: define functions for variable expansion on `Binding??` // TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error @@ -403,187 +436,289 @@ impl BindingInput { return false; } - fn expand_foreach(&mut self) -> ResultVec> { - let mut result = vec![self.clone()]; - while self.has_foreach() { - result = self.expand_foreach_once(&result)?; + pub fn expand_foreach(mut self) -> ResultVec> { + if self.has_foreach() { + let foreach = expand_keys(self.foreach.clone().unwrap())?; + foreach.require_constant().context_str( + "`foreach` values can only include expressions of the form {{keys(`regex`)}}", + )?; + + let values = expand_foreach_values(foreach).into_iter().map(|values| { + self.clone() + .map_expressions(&|x| { + Ok(values + .get(&x) + .map_or_else(|| Value::Expression(x), |ex| ex.clone())) + }) + .expect("no errors") // since our mapping function has no errors + }); + return Ok(values.collect()); } - return Ok(result); + return Ok(vec![self]); } +} - fn expand_foreach_once(&mut self, inputs: &Vec) -> ResultVec> { - let foreach = match self.foreach { - Some(ref mut foreach) => foreach, - None => &mut IndexMap::new(), - }; - let final_foreach = foreach.split_off(1); - let mut iter = foreach.iter(); - let first = iter.next(); - if let Some(item) = first { - let (var, values) = item; - - let expanded_items = expand_keys(values)?; - let mut result = Vec::with_capacity(inputs.len() * expanded_items.len()); - for input in inputs { - for value in &expanded_items { - let mut expanded = input.clone(); - expanded.expand_value(var, value)?; - result.push(expanded); - } - } - if final_foreach.len() > 0 { - self.foreach = Some(final_foreach); - } else { - self.foreach = None; - } - return Ok(result); - } else { - return Ok(vec![]); - } +fn expand_foreach_values(foreach: IndexMap>) -> Vec> { + let mut result = vec![IndexMap::new()]; + + for (k, vals) in foreach { + result = result + .iter() + .flat_map(|seed| { + vals.iter().map(|v| { + let mut with_k = seed.clone(); + with_k.insert(k.clone(), v.clone()); + return with_k; + }) + }) + .collect(); } + + return result; } -impl VariableExpanding for BindingInput { - fn expand_with_getter(&mut self, getter: F) -> ResultVec<()> +impl Expanding for BindingInput { + fn is_constant(&self) -> bool { + [ + self.command.is_constant(), + self.args.is_constant(), + self.key.is_constant(), + self.when.is_constant(), + self.mode.is_constant(), + self.priority.is_constant(), + self.default.is_constant(), + self.foreach.is_constant(), + self.prefixes.is_constant(), + self.finalKey.is_constant(), + self.repeat.is_constant(), + self.name.is_constant(), + self.description.is_constant(), + self.hideInPalette.is_constant(), + self.hideInDocs.is_constant(), + self.combinedName.is_constant(), + self.combinedKey.is_constant(), + self.combinedDescription.is_constant(), + self.kind.is_constant(), + ] + .into_iter() + .all(identity) + } + fn map_expressions(self, f: &F) -> ResultVec where - F: Fn(&str) -> Result>, - F: Clone, + F: Fn(String) -> Result, { - self.command.expand_with_getter(getter.clone())?; - self.args.expand_with_getter(getter.clone())?; - self.key.expand_with_getter(getter.clone())?; - self.when.expand_with_getter(getter.clone())?; - self.mode.expand_with_getter(getter.clone())?; - self.priority.expand_with_getter(getter.clone())?; - self.default.expand_with_getter(getter.clone())?; - self.prefixes.expand_with_getter(getter.clone())?; - self.finalKey.expand_with_getter(getter.clone())?; - self.repeat.expand_with_getter(getter.clone())?; - self.name.expand_with_getter(getter.clone())?; - self.description.expand_with_getter(getter.clone())?; - self.hideInPalette.expand_with_getter(getter.clone())?; - self.hideInDocs.expand_with_getter(getter.clone())?; - self.combinedName.expand_with_getter(getter.clone())?; - self.combinedKey.expand_with_getter(getter.clone())?; - self.combinedDescription - .expand_with_getter(getter.clone())?; - self.kind.expand_with_getter(getter.clone())?; - return Ok(()); - } -} - -fn regularize_commands(input: BindingInput) -> Result<(BindingInput, Vec)> { - let command = input.command.get_ref().clone().resolve("`command` field")?; - let args = input.args.clone(); - if command == "runCommands" { - let spanned = args - .require("`args` field") - .context_str("`runCommands` must have `args` field") - .context_range(&input.command)?; - let args_pos = spanned.span(); - let args = spanned.into_inner(); - let commands = args - .get("commands") - .require("`commands` field") - .context_str("`runCommands.args` must have a `commands` fields") - .context_range(&args_pos)?; - let commands = commands.as_array().require("`commands` to be an array")?; - let mut command_result = Vec::with_capacity(commands.len()); - for command in commands { - let (command, args) = match command { - Value::String(str) => (str.to_owned(), toml::Table::new()), - Value::Table(kv) => { - let command_name = kv - .get("command") - .require("`command` field")? - .as_str() - .require("`command` to be string") - .context_range(&args_pos)? - .to_owned(); - let args = command - .get("args") - .require("`args` field")? - .as_table() - .require("`args` to be a table")? - .to_owned(); - (command_name, args) - } - _ => { - return constrain( - "`commands` to be an array that includes objects and strings only", - )?; - } - }; - - command_result.push(Command { command, args }) - } - - return Ok((input, command_result)); - } else { - return Ok(( - input, - vec![Command { - command, - args: match args { - Some(x) => x.into_inner(), - None => toml::Table::new(), + let mut errors = Vec::new(); + let result = BindingInput { + id: self.id, + foreach: self.foreach.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + command: self.command.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) + }), + args: self.args.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + key: self.key.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) + }), + when: self.when.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + mode: self.mode.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Plural::Zero) + }), + priority: self.priority.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + default: self.default.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + prefixes: self.prefixes.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Plural::Zero) + }), + finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + repeat: self.repeat.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + name: self.name.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + description: self.description.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + hideInPalette: self + .hideInPalette + .map_expressions(f) + .unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + hideInDocs: self.hideInDocs.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + combinedName: self + .combinedName + .map_expressions(f) + .unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + combinedKey: self.combinedKey.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + combinedDescription: self.combinedDescription.map_expressions(f).unwrap_or_else( + |mut e| { + errors.append(&mut e.errors); + None }, - }], - )); + ), + kind: self.kind.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + }; + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } } } -// TODO: think about whether I want to represent commands as a sequence in the output... -impl Binding { - pub fn new(input: BindingInput) -> Result { - if let Some(_) = input.id { - return reserved("id"); - } - - serde_wasm_bindgen::Serializer::json_compatible(); - if let Some(_) = input.foreach { - return unexpected("`foreach` with unresolved variables"); - } - let (input, commands) = regularize_commands(input)?; - - // TODO this is where we should validate that prefix has `finalKey == false` - - return Ok(Binding { - commands: commands, - key: input.key.into_inner().require("`key` field")?.unwrap(), - when: input.when.into_inner().to_array(), - mode: input.mode.into_inner().to_array(), - priority: input - .priority - .map(|x| x.into_inner().resolve("`priority` field")) - .unwrap_or_else(|| Ok(0))?, - prefixes: input.prefixes.into_inner().to_array(), - finalKey: input - .finalKey - .map(|x| x.into_inner().resolve("`finalKey` field")) - .unwrap_or_else(|| Ok(true))?, - repeat: input.repeat.map(|x| x.into_inner()), - name: input.name.map(|x| x.into_inner()), - description: input.description.map(|x| x.into_inner()), - hideInPalette: input - .hideInPalette - .map(|x| x.into_inner().resolve("`hideInPalette` field")) - .unwrap_or_else(|| Ok(false))?, - hideInDocs: input - .hideInDocs - .map(|x| x.into_inner().resolve("`hideInDocs` field")) - .unwrap_or_else(|| Ok(false))?, - combinedName: input.combinedName.map(|x| x.into_inner()), - combinedKey: input.combinedKey.map(|x| x.into_inner()), - combinedDescription: input.combinedDescription.map(|x| x.into_inner()), - kind: input.kind.clone().map(|x| x.into_inner()), - }); - } +fn regularize_commands(input: BindingInput) -> ResultVec<(BindingInput, Vec)> { + return Err(Error::Unexpected("TODO"))?; + // // TODO: this works with TOML values, need to figure out how to + // // work with Value's since some of them can be expressions + // let command_value: toml::Value = input.command.into(); + // let command = command_value.get_ref().clone().resolve("`command` field")?; + // let args = input.args.clone(); + // if command == "runCommands" { + // let spanned = args + // .require("`args` field") + // .context_str("`runCommands` must have `args` field") + // .context_range(&command_value)?; + // let args_pos = spanned.span(); + // let args = spanned.into_inner(); + // let commands = args + // .get("commands") + // .require("`commands` field") + // .context_str("`runCommands.args` must have a `commands` fields") + // .context_range(&args_pos)?; + // let commands = commands.as_array().require("`commands` to be an array")?; + // let mut command_result = Vec::with_capacity(commands.len()); + // for command in commands { + // let (command, args) = match command { + // Value::String(str) => (str.to_owned(), toml::Table::new()), + // Value::Table(kv) => { + // let command_name = kv + // .get("command") + // .require("`command` field")? + // .as_str() + // .require("`command` to be string") + // .context_range(&args_pos)? + // .to_owned(); + // let args = command + // .get("args") + // .require("`args` field")? + // .as_table() + // .require("`args` to be a table")? + // .to_owned(); + // (command_name, args) + // } + // _ => { + // return constrain( + // "`commands` to be an array that includes objects and strings only", + // )?; + // } + // }; + + // command_result.push(Command { command, args }) + // } + + // return Ok((input, command_result)); + // } else { + // return Ok(( + // input, + // vec![Command { + // command, + // args: match args { + // Some(x) => x.into_inner(), + // None => toml::Table::new(), + // }, + // }], + // )); + // } } +// impl Binding { +// pub fn new(input: BindingInput) -> ResultVec { +// if let Some(_) = input.id { +// return reserved("id"); +// } + +// serde_wasm_bindgen::Serializer::json_compatible(); +// if let Some(_) = input.foreach { +// return unexpected("`foreach` with unresolved variables"); +// } +// let (input, commands) = regularize_commands(input)?; + +// // TODO this is where we should validate that prefix has `finalKey == false` + +// // TODO: cleanup below now that we've updated types for `BindingInput` +// return Ok(Binding { +// commands: commands, +// key: input.key.into_inner().require("`key` field")?.unwrap(), +// when: input.when.into_inner().to_array(), +// mode: input.mode.into_inner().to_array(), +// priority: input +// .priority +// .map(|x| x.into_inner().resolve("`priority` field")) +// .unwrap_or_else(|| Ok(0))?, +// prefixes: input.prefixes.into_inner().to_array(), +// finalKey: input +// .finalKey +// .map(|x| x.into_inner().resolve("`finalKey` field")) +// .unwrap_or_else(|| Ok(true))?, +// repeat: input.repeat.map(|x| x.into_inner()), +// name: input.name.map(|x| x.into_inner()), +// description: input.description.map(|x| x.into_inner()), +// hideInPalette: input +// .hideInPalette +// .map(|x| x.into_inner().resolve("`hideInPalette` field")) +// .unwrap_or_else(|| Ok(false))?, +// hideInDocs: input +// .hideInDocs +// .map(|x| x.into_inner().resolve("`hideInDocs` field")) +// .unwrap_or_else(|| Ok(false))?, +// combinedName: input.combinedName.map(|x| x.into_inner()), +// combinedKey: input.combinedKey.map(|x| x.into_inner()), +// combinedDescription: input.combinedDescription.map(|x| x.into_inner()), +// kind: input.kind.clone().map(|x| x.into_inner()), +// }); +// } +// } + #[cfg(test)] mod tests { - use std::collections::HashMap; + use std::{collections::HashMap, io::Write}; use test_log::test; use super::*; @@ -600,7 +735,7 @@ mod tests { foreach.index = [1,2,3] prefixes = "c" finalKey = true - repeat = "2+c" + repeat = "{{2+c}}" name = "foo" description = "foo bar bin" hideInPalette = false @@ -611,63 +746,82 @@ mod tests { kind = "biz" "#; + io::stdout().flush().unwrap(); + let result = toml::from_str::(data).unwrap(); - assert_eq!(result.command.into_inner(), Required::Value("do".into())); - let args = result.args.unwrap().into_inner(); - assert_eq!(args.get("a").unwrap(), &Value::String("2".into())); - assert_eq!(args.get("b").unwrap(), &Value::Integer(3)); - assert_eq!(result.key.into_inner().unwrap().unwrap(), "a"); - assert_eq!(result.when.into_inner(), Plural::One("joe > 1".into())); - assert_eq!(result.mode.into_inner(), Plural::One("normal".into())); - assert_eq!(result.priority.map(|x| x.into_inner()).unwrap().unwrap(), 1); assert_eq!( - result.default.map(|x| x.into_inner()).as_ref().unwrap(), - &BindingReference::try_from(String::from("{{bind.foo_bar}}")).unwrap() - ); - assert_eq!( - result - .foreach - .unwrap() - .get("index") - .unwrap() - .iter() - .map(|x| x.get_ref().as_integer().unwrap()) - .collect::>(), - vec![1, 2, 3], - ); - assert_eq!(result.prefixes.into_inner(), Plural::One("c".into())); - assert_eq!( - result.finalKey.map(|x| x.into_inner()).unwrap().unwrap(), - true - ); - assert_eq!(result.name.map(|x| x.into_inner()).unwrap(), "foo"); - assert_eq!( - result.description.map(|x| x.into_inner()).unwrap(), - "foo bar bin" - ); - assert_eq!( - result.hideInDocs.map(|x| x.into_inner()).unwrap().unwrap(), - false + String::from(result.command.into_inner().unwrap()), + "do".to_string() ); + + let args = result.args.unwrap().into_inner(); assert_eq!( - result - .hideInPalette - .map(|x| x.into_inner()) - .unwrap() - .unwrap(), - false + args, + Value::Table(IndexMap::from([ + ("a".into(), Value::String("2".into())), + ("b".into(), Value::Integer(3)) + ])) ); + let key: String = result.key.into_inner().unwrap().into(); + assert_eq!(key, "a".to_string()); + let when: String = result.when.unwrap().into_inner().into(); + assert_eq!(when, "joe > 1".to_string()); + let mode: Vec = result + .mode + .into_inner() + .map(|m| m.clone().into()) + .to_array(); + + assert_eq!(mode, ["normal"]); + let priority: f64 = result.priority.unwrap().into_inner().into(); + assert_eq!(priority, 1.0); assert_eq!( - result.combinedName.map(|x| x.into_inner()).unwrap(), - "Up/down" + result.default.unwrap().into_inner().0, + "bind.foo_bar".to_string() ); - assert_eq!(result.combinedKey.map(|x| x.into_inner()).unwrap(), "A/B"); + let foreach = result.foreach.unwrap(); + let values = foreach.get("index").unwrap(); + let numbers: Vec = values.iter().map(|it| it.clone().into_inner()).collect(); assert_eq!( - result.combinedDescription.map(|x| x.into_inner()).unwrap(), - "bla bla bla" + numbers, + [Value::Integer(1), Value::Integer(2), Value::Integer(3)] ); - assert_eq!(result.kind.map(|x| x.into_inner()).unwrap(), "biz"); + + assert_eq!(when, "joe > 1".to_string()); + let prefixes: Vec = result + .prefixes + .into_inner() + .map(|m| m.clone().into()) + .to_array(); + assert_eq!(prefixes, ["c"]); + + let finalKey: bool = result.finalKey.unwrap().into_inner().into(); + assert_eq!(finalKey, true); + + let name: String = result.name.unwrap().into_inner().into(); + assert_eq!(name, "foo"); + + let description: String = result.description.unwrap().into_inner().into(); + assert_eq!(description, "foo bar bin"); + + let hideInDocs: bool = result.hideInDocs.unwrap().into_inner().into(); + assert_eq!(hideInDocs, false); + + let hideInPalette: bool = result.hideInPalette.unwrap().into_inner().into(); + assert_eq!(hideInPalette, false); + + let combinedName: String = result.combinedName.unwrap().into_inner().into(); + assert_eq!(combinedName, "Up/down"); + + let combinedKey: String = result.combinedKey.unwrap().into_inner().into(); + assert_eq!(combinedKey, "A/B"); + + let combinedDescription: String = result.combinedDescription.unwrap().into_inner().into(); + assert_eq!(combinedDescription, "bla bla bla"); + + let kind: String = result.kind.unwrap().into_inner().into(); + assert_eq!(kind, "biz"); } #[test] @@ -679,21 +833,26 @@ mod tests { "#; let result = toml::from_str::(data).unwrap(); - assert_eq!(result.key.into_inner().unwrap().unwrap(), "l"); - assert_eq!(result.command.into_inner().unwrap(), "cursorMove"); assert_eq!( - result - .args - .unwrap() - .into_inner() - .get("to") - .unwrap() - .as_str() - .unwrap(), - "left" + String::from(result.key.into_inner().unwrap()), + "l".to_string() + ); + assert_eq!( + String::from(result.command.into_inner().unwrap()), + "cursorMove" + ); + assert_eq!( + result.args.unwrap().into_inner(), + Value::Table(IndexMap::from([( + "to".into(), + Value::String("left".into()) + )])) ); - assert_eq!(result.when.into_inner(), Plural::Zero); + assert_eq!( + String::from(result.mode.into_inner().to_array().first().unwrap().clone()), + "default".to_string() + ); assert_eq!(result.combinedDescription, None); assert_eq!(result.combinedName, None); } @@ -717,24 +876,29 @@ mod tests { let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let left = default.merge(left); - assert_eq!(left.key.into_inner().unwrap().unwrap(), "l"); - assert_eq!(left.command.into_inner().unwrap(), "cursorMove"); + + let key: String = left.key.into_inner().unwrap().into(); + assert_eq!(key, "l".to_string()); assert_eq!( - left.args - .unwrap() - .into_inner() - .get("to") - .unwrap() - .as_str() - .unwrap(), - "left" + String::from(left.command.into_inner().unwrap()), + "cursorMove" ); + assert_eq!( - left.prefixes.into_inner(), - Plural::Many(vec!["b".into(), "c".into()]) + left.args.unwrap().into_inner(), + Value::Table(IndexMap::from([( + "to".into(), + Value::String("left".into()) + )])) ); - assert_eq!(left.when.into_inner(), Plural::Zero); + let prefixes: Vec = left + .prefixes + .into_inner() + .map(|m| m.clone().into()) + .to_array(); + assert_eq!(prefixes, ["b".to_string(), "c".to_string()]); + assert_eq!(left.combinedDescription, None); assert_eq!(left.combinedName, None); } @@ -795,7 +959,6 @@ mod tests { command = "step2" args.y = "fiz" - [[bind]] name = "run_merged" key = "x" @@ -832,24 +995,6 @@ mod tests { let mut result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); - // for it in items.iter() { - // info!("{}", "{"); - // info!(" name: {}", it.name.clone().unwrap().get_ref()); - // info!(" command: {}", it.command.get_ref().clone().unwrap()); - // info!( - // " args.value: {}", - // it.args - // .clone() - // .unwrap() - // .get_ref() - // .get("value") - // .unwrap() - // .as_str() - // .unwrap() - // ); - // info!("{}", "}"); - // } - let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; let expected_value = vec!["with-x", "with-y", "with-x", "with-y"]; let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; @@ -857,19 +1002,20 @@ mod tests { for i in 0..4 { let item = items[i].clone(); assert_eq!( - item.command.as_ref().clone().unwrap().as_str(), + String::from(item.command.into_inner().unwrap()), expected_command[i] ); - assert_eq!(item.name.unwrap().as_ref().as_str(), expected_name[i]); + + assert_eq!( + String::from(item.name.unwrap().into_inner()), + expected_name[i] + ); assert_eq!( - item.args - .unwrap() - .as_ref() - .get("value") - .unwrap() - .as_str() - .unwrap(), - expected_value[i] + item.args.unwrap().into_inner(), + Value::Table(IndexMap::from([( + "value".to_string(), + Value::String(expected_value[i].into()) + )])) ); } } @@ -879,7 +1025,7 @@ mod tests { // TODO: error out if the regex inside of `{{}}` is not valid (right now it just // fails silently) let data = r#" - foreach.key = ["{{key(`[0-9]`)}}"] + foreach.key = ["{{keys(`[0-9]`)}}"] name = "update {{key}}" command = "foo" args.value = "{{key}}" @@ -894,9 +1040,16 @@ mod tests { assert_eq!(items.len(), 10); for i in 0..9 { - assert_eq!(items[i].name.as_ref().unwrap().get_ref(), &expected_name[i]); - let value = items[i].args.as_ref().unwrap().get_ref().get("value"); - assert_eq!(value.unwrap().as_str().unwrap(), expected_value[i]); + let name: String = items[i].name.as_ref().unwrap().get_ref().clone().into(); + assert_eq!(name, expected_name[i]); + let value = items[i].args.as_ref().unwrap().get_ref().clone(); + assert_eq!( + value, + Value::Table(IndexMap::from([( + "value".to_string(), + Value::String(expected_value[i].clone()) + )])) + ); } } diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index c94849d0..001989fc 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -1,10 +1,14 @@ -use crate::error::{ErrorContext, Result}; +use std::collections::VecDeque; +use indexmap::IndexMap; use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use toml::{Spanned, Value}; +use toml::Spanned; + +use crate::error::{ErrorContext, Result, ResultVec}; +use crate::value::{Expanding, Value}; const ALL_KEYS: [&'static str; 192] = [ "f0", @@ -202,25 +206,44 @@ const ALL_KEYS: [&'static str; 192] = [ ]; lazy_static! { - static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"\{\{\s*key\(\s*`(.*)`\s*\)\s*\}\}").unwrap(); + static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); + // static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); } -pub fn expand_keys(items: &Vec>) -> Result> { - let mut result = Vec::new(); - - for item in items { - if let Value::String(str_item) = item.get_ref() { - if let Some(caps) = KEY_PATTERN_REGEX.captures(&str_item) { - let key_regex = Regex::new(&caps[1]).context_range(&item.span())?; - for key in ALL_KEYS { - if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { - result.push(Value::String(key.into())); - } - } - continue; +fn expand_keys_str(val: String) -> Result { + let c = KEY_PATTERN_REGEX.captures(&val); + if let Some(caps) = c { + let key_regex = Regex::new(&caps[1])?; + let mut result = Vec::new(); + for key in ALL_KEYS { + if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { + result.push(Value::String(key.into())); } } - result.push(item.get_ref().clone()); + return Ok(Value::Array(result)); + } else { + return Ok(Value::Expression(val)); } - return Ok(result); +} + +pub fn expand_keys( + items: IndexMap>>, +) -> ResultVec>> { + // expand any `{{key(`regex`)}}` expressions (these are arrays of possible keys) + let items = items.map_expressions(&expand_keys_str)?; + + // flatten any arrays + return Ok(items + .into_iter() + .map(|(k, v)| { + let vals = v + .into_iter() + .flat_map(|i| match i.into_inner() { + Value::Array(x) => x, + x @ _ => vec![x], + }) + .collect(); + return (k.clone(), vals); + }) + .collect()); } diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 089bd5ba..0aed8d65 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,7 +1,6 @@ -use crate::error::{Error, ErrorWithContext, Result, ResultVec}; +use crate::error::{Error, ErrorWithContext, ErrorsWithContext, Result, ResultVec}; use crate::util::Merging; -use crate::variable; -use crate::variable::{As, VAR_STRING, Value, ValueEnum, VariableExpanding}; +use crate::value::{EXPRESSION, Expanding, TypedValue, Value}; #[allow(unused_imports)] use log::info; @@ -116,59 +115,54 @@ fn valid_key_binding_str(str: &str) -> Result<()> { #[derive(Serialize, Deserialize, Clone, Debug)] #[serde(try_from = "String", into = "String")] -pub struct KeyBinding(ValueEnum); +pub struct KeyBinding(TypedValue); impl TryFrom for KeyBinding { - type Error = crate::error::ErrorWithContext; - fn try_from(value: String) -> Result { - match BIND_STRING.captures(&value) { - Some(captures) => { - return Ok(KeyBinding(ValueEnum::Variable( - captures.get(1).expect("variable name").as_str().into(), - ))); - } - None => { - valid_key_binding_str(&value)?; - return Ok(KeyBinding(ValueEnum::Literal(value))); - } - } - } -} - -impl From for String { - fn from(value: KeyBinding) -> Self { - match value.0 { - ValueEnum::Literal(x) => x, - ValueEnum::Variable(x) => format!("{}{x}{}", "{{", "}}"), + type Error = ErrorsWithContext; + fn try_from(value: String) -> ResultVec { + if EXPRESSION.is_match(&value) { + return Ok(KeyBinding(TypedValue::Variable( + toml::Value::String(value).try_into()?, + ))); + } else { + valid_key_binding_str(&value)?; + return Ok(KeyBinding(TypedValue::Constant(value))); } } } -impl As for toml::Value { - fn astype(&self) -> crate::error::Result { +impl Expanding for KeyBinding { + fn is_constant(&self) -> bool { match self { - toml::Value::String(str) => Ok(KeyBinding::try_from(str.clone())?), - _ => Err(Error::Constraint("a string describing a keybinding".into()))?, + KeyBinding(TypedValue::Constant(_)) => true, + KeyBinding(TypedValue::Variable(_)) => false, } } -} - -impl VariableExpanding for KeyBinding { - fn expand_with_getter(&mut self, getter: F) -> crate::error::ResultVec<()> + fn map_expressions(self, f: &F) -> ResultVec where - F: Fn(&str) -> crate::error::Result>, - F: Clone, + F: Fn(String) -> Result, { - match &mut self.0 { - ValueEnum::Literal(_) => (), - ValueEnum::Variable(str) => { - let mut new_str = str.clone(); - new_str.expand_with_getter(getter)?; - let new = KeyBinding::try_from(new_str)?; - self.0 = new.0; - } + Ok(match self { + KeyBinding(TypedValue::Constant(ref x)) => self, + KeyBinding(TypedValue::Variable(value)) => match value.map_expressions(f)? { + interp @ Value::Interp(_) => KeyBinding(TypedValue::Variable(interp)), + exp @ Value::Expression(_) => KeyBinding(TypedValue::Variable(exp)), + Value::String(val) => { + valid_key_binding_str(&val)?; + KeyBinding(TypedValue::Constant(val)) + } + other @ _ => return Err(Error::Unexpected("non-string value"))?, + }, + }) + } +} + +impl From for String { + fn from(value: KeyBinding) -> Self { + match value { + KeyBinding(TypedValue::Constant(x)) => x, + KeyBinding(TypedValue::Variable(value)) => panic!("Unresolved expression {value:?}"), } - return Ok(()); } } @@ -183,41 +177,61 @@ impl Merging for KeyBinding { impl KeyBinding { pub fn unwrap(self) -> String { - match self.0 { - ValueEnum::Literal(x) => x, - ValueEnum::Variable(_) => panic!("unresolved variable"), + match self { + KeyBinding(TypedValue::Constant(x)) => x, + KeyBinding(TypedValue::Variable(_)) => panic!("unresolved variable"), } } } lazy_static! { - static ref BIND_STRING: Regex = Regex::new(r"\{\{(bind\.[\w--\d]\w*)\}\}").unwrap(); + static ref BIND_VARIABLE: Regex = Regex::new(r"bind\.([\w--\d][\w]*)").unwrap(); } -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] -#[serde(try_from = "String")] -pub struct BindingReference(variable::Value); +#[derive(Deserialize, Clone, Debug)] +#[serde(try_from = "String", into = "String")] +pub struct BindingReference(pub(crate) String); impl TryFrom for BindingReference { - type Error = ErrorWithContext; - fn try_from(value: String) -> Result { - let captures = BIND_STRING.captures(&value).ok_or_else(|| { - crate::error::Error::Validation( - "binding reference; must be of the form `{{bind.[identifier]}})".into(), - ) - })?; - let name = captures.get(1).expect("`bind.` identifier capture"); - return Ok(BindingReference(variable::Value::var(name.as_str().into()))); + type Error = ErrorsWithContext; + fn try_from(value: String) -> ResultVec { + let value: Value = toml::Value::String(value).try_into()?; + match value { + Value::Expression(x) => { + if !BIND_VARIABLE.is_match(&x) { + Err(Error::Validation( + "binding reference (must be of the form `{{bind.[identifier]}}`".into(), + ))?; + } + return Ok(BindingReference(x)); + } + _ => Err(Error::Validation( + "binding reference (must be of the form `{{bind.[identifier]}}`".into(), + ))?, + } } } -impl VariableExpanding for BindingReference { - fn expand_with_getter(&mut self, getter: F) -> crate::error::ResultVec<()> +// This implementation of `Expanding` may seem unintuitive, but we don't actually use +// `map-expressions` to expand `BindingReference` instead we review review these values +// during a separate `BindingInput` resolution phase. During variable expansion, we simply +// want to ignore the `{{bind.}}` expression present in `BindingReference` +impl Expanding for BindingReference { + fn is_constant(&self) -> bool { + false + } + fn map_expressions(self, f: &F) -> ResultVec where - F: Fn(&str) -> crate::error::Result>, - F: Clone, + Self: Sized, + F: Fn(String) -> Result, { - return self.0.expand_with_getter(getter); + return Ok(self); + } +} + +impl From for String { + fn from(value: BindingReference) -> Self { + return value.0; } } @@ -225,13 +239,8 @@ impl Merging for BindingReference { fn coalesce(self, new: Self) -> Self { return new; } + fn merge(self, new: Self) -> Self { return new; } } - -impl BindingReference { - pub fn unwrap(self) -> toml::Value { - return self.0.unwrap(); - } -} diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 586ccbe3..b7f8e5d6 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,439 +1,441 @@ -use core::error; -use std::collections::HashMap; - -use crate::bind::{Binding, BindingInput, Command, CommandInput}; -use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; -use crate::util::Requiring; -use crate::variable::VariableExpanding; - -use indexmap::IndexMap; -#[allow(unused_imports)] -use log::info; -use serde::{Deserialize, Serialize}; -use serde_wasm_bindgen; -use toml::Spanned; -use wasm_bindgen::prelude::*; - -#[derive(Deserialize, Serialize, Clone, Debug)] -pub struct DefineInput { - pub var: Option>>>, - pub command: Option>>, - pub bind: Option>>, -} - -pub trait VariableResolver { - fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()>; -} - -#[wasm_bindgen] -#[derive(Clone, Debug, Default)] -pub struct Define { - #[wasm_bindgen(skip)] - pub bind: HashMap, - #[wasm_bindgen(skip)] - pub command: HashMap, - #[wasm_bindgen(skip)] - pub var: HashMap, -} - -fn map_with_err(x: HashMap>, f: &mut F) -> ResultVec> -where - F: FnMut(T) -> Result, -{ - let mut errors = Vec::new(); - let result = x - .into_iter() - .filter_map(|(k, v)| { - let span = v.span(); - let result = f(v.into_inner()).context_range(&span); - return result.map_err(|e| errors.push(e)).ok().map(|v| (k, v)); - }) - .collect(); - if errors.len() > 0 { - return Err(errors); - } else { - return Ok(result); - } -} - -impl Define { - pub fn new(input: DefineInput) -> ResultVec { - // STEP 1: resolve all definitions so that there are no interpolations of - // `var.`, `bind.` or `command.` variables - let mut resolved_bind = HashMap::>::new(); - let mut resolved_command = HashMap::>::new(); - let mut resolved_var = HashMap::::new(); - let mut errors = Vec::new(); - - // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they - // must only reference previously defined variables (we've included the TOML feature - // to preserve order, so variables can reference other variables defined within the - // same block) - - // TODO: do not resolve `var` values, and do not allow `{{}}` inside of `var.` values - for def_block in input.var.into_iter().flatten() { - for (var, mut value) in def_block.into_iter() { - let mut var_result = value.expand_with_getter(|id| { - if let Some((prefix, name)) = id.split_once('.') { - if prefix == "var" { - return Err(Error::Constraint( - "no references to `var` within a `var` definition".into() - ))?; - } else if prefix == "bind" || prefix == "command" { - return Err(Error::ForwardReference(format!( - "`{id}`; you cannot refer to `{prefix}` values within `var` definitions" - )))?; - } - } - // TODO: refactor so that we use a unique enum type instead of - // Some/None to signal resolution - - // other types of variables are left unresolved - return Ok(None); - }); - if let Err(ref mut errs) = var_result { - errors.append(errs); - } - resolved_var.insert(var.clone(), value.get_ref().clone()); - } - } - - // STEP 1b: resolve [[define.command]] blocks - for mut def in input.command.into_iter().flatten() { - let mut command_result = def.get_mut().expand_with_getter(|id| { - if let Some((prefix, name)) = id.split_once('.') { - if prefix == "var" { - let value = resolved_var - .get(name) - .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; - return Ok(Some(value.clone())); - } else if prefix == "command" { - let val = resolved_command.get(id).ok_or_else(|| { - Error::UndefinedVariable(format!("`{id}`")) - })?; - return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)) - } else if prefix == "bind" { - return Err(Error::ForwardReference(format!( - "`{id}`; you cannot refer to `{prefix}` values within `command` definitions" - )))?; - } - } - return Ok(None); - }); - if let Err(ref mut errs) = command_result { - errors.append(errs); - } - - let id = def.get_ref().id.clone(); - resolved_command.insert( - id.require("id") - .context_range(&def.span())? - .get_ref() - .clone(), - def, - ); - } - - // STEP 1c: resolve [[define.bind]] blocks - for mut def in input.bind.into_iter().flatten() { - let mut bind_result = def.get_mut().expand_with_getter(|id| { - if let Some((prefix, name)) = id.split_once('.') { - if prefix == "var" { - let value = resolved_var - .get(name) - .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; - return Ok(Some(value.clone())); - } else if prefix == "command" { - let val = resolved_command - .get(name) - .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; - return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); - } else if prefix == "bind" { - let val = resolved_bind - .get(name) - .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; - return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); - } - } - return Ok(None); - }); - if let Err(ref mut errs) = bind_result { - errors.append(errs); - } - - let id = def.get_ref().id.clone(); - resolved_bind.insert( - id.require("id") - .context_range(&def.span())? - .get_ref() - .clone(), - def, - ); - } - - // STEP 2: cleanup results for use in `Define` struct - - if errors.len() > 0 { - return Err(errors); - } else { - // TODO: because resolution to the Binding and Command structs does not occur until - // later, we could, in theory end up with a *lot* of errors for the same lines, it - // will be important to clean up the output to only show one of these errors and - // remove the other instances; or convince our selves no such issue will arise - let bind = resolved_bind - .into_iter() - .map(|(k, v)| (k, v.into_inner().without_id())) - .collect(); - let command = map_with_err(resolved_command, &mut |c| Command::new(c.without_id()))?; - return Ok(Define { - bind, - command, - var: resolved_var, - }); - } - } -} - -// NOTE: why don't we provide public access to `bind` and `command`: this avoids -// extra implementation work, when the main use case for these two categories of -// definitions is to make the binding file more concise; `var.` values on -// the other hand are often used at runtime -#[wasm_bindgen] -impl Define { - pub fn var(&self, key: &str) -> Result { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - let value = self.var.get(key).require(format!("`{key}` field"))?; - return match value.serialize(&to_json) { - Ok(result) => Ok(result), - Err(_) => unexpected("unexpected serialization error"), - }; - } -} - -// TODO: we don't actually want to resolve `var.`s as they might change during runtime -// TODO: we need to avoid parsing expressions as variables to insert - -impl VariableResolver for Define { - fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()> { - x.expand_with_getter(|var| { - if let Some((prefix, name)) = var.split_once('.') { - if prefix == "var" { - return Ok(Some( - self.var - .get(name) - .ok_or_else(|| Error::UndefinedVariable(var.into()))? - .clone(), - )); - } else if prefix == "command" { - let val = self - .command - .get(name) - .ok_or_else(|| Error::UndefinedVariable(var.into()))? - .clone(); - return Ok(Some(toml::Value::try_from(val)?)); - } else if prefix == "bind" { - let val = self - .bind - .get(name) - .ok_or_else(|| Error::UndefinedVariable(var.into()))? - .clone(); - return Ok(Some(toml::Value::try_from(val)?)); - } - } - return Ok(None); - })?; - return Ok(()); - } -} - -mod tests { - use test_log::test; - - use super::*; - #[test] - fn simple_parsing() { - let data = r#" - [[var]] - y = "bill" - - [[bind]] - id = "foo" - key = "x" - command = "foo" - args = { k = 1, h = 2 } - - [[command]] - id = "foobar" - command = "runCommands" - args.commands = ["foo", "bar"] - - [[var]] - joe = "bob" - - "#; - - let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - - assert_eq!(result.var.get("y").unwrap().as_str().unwrap(), "bill"); - assert_eq!(result.var.get("joe").unwrap().as_str().unwrap(), "bob"); - let foo = result.bind.get("foo").unwrap(); - assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); - assert_eq!( - foo.args - .as_ref() - .unwrap() - .get_ref() - .get("k") - .unwrap() - .as_integer() - .unwrap(), - 1 - ); - - assert_eq!( - foo.args - .as_ref() - .unwrap() - .get_ref() - .get("h") - .unwrap() - .as_integer() - .unwrap(), - 2 - ); - - let foobar = result.command.get("foobar").unwrap(); - assert_eq!(foobar.command, "runCommands"); - let commands = foobar.args.get("commands").unwrap().as_array().unwrap(); - assert_eq!(commands[0].as_str().unwrap(), "foo"); - assert_eq!(commands[1].as_str().unwrap(), "bar"); - } - - #[test] - fn parsing_resolved_variables() { - let data = r#" - [[var]] - foo = 1 - - [[var]] - foo_string = "number-{{var.foo}}" - - [[command]] - id = "run_shebang" - command = "shebang" - args.a = 1 - args.b = "{{var.foo_string}}" - - [[bind]] - id = "whole_shebang" - key = "a" - name = "the whole shebang" - command = "runCommands" - args.commands = ["{{command.run_shebang}}", "bar"] - "#; - - let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - let bind_args = result - .bind - .get("whole_shebang") - .as_ref() - .unwrap() - .args - .as_ref() - .unwrap(); - let bind_commands = bind_args - .get_ref() - .get("commands") - .unwrap() - .as_array() - .unwrap(); - assert_eq!( - bind_commands[0].get("command").unwrap().as_str().unwrap(), - "shebang" - ); - assert_eq!( - bind_commands[0] - .get("args") - .unwrap() - .get("b") - .unwrap() - .as_str() - .unwrap(), - "number-1" - ); - assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); - } - - #[test] - fn parsing_order_error() { - let data = r#" - [[var]] - k = "{{command.foo}}" - - [[var]] - a = 1 - - [[var]] - b = "{{var.a}}-boot" - - [[command]] - id = "foo" - command = "joe" - args.x = 1 - - [[command]] - id = "bar" - command = "runCommands" - args.commands = ["{{command.biz}}", "baz"] - - [[command]] - id = "biz" - command = "bob" - args.y = 2 - args.x = "{{bind.horace}}" - - [[bind]] - id = "horace" - key = "ctrl+k" - command = "cursorLeft" - args.value = "{{count}}" - - [[bind]] - default = "{{bind.horace}}" - id = "bob" - key = "ctrl+y" - command = "cursorRight" - - [[bind]] - default = "{{bind.will}}" - id = "bob" - key = "ctrl+k" - command = "cursorDown" - "#; - // TODO: add `default` key to `bind` so we can accomplish the todo below - // TODO: test for missing `bind` - let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); - assert!(if let Error::ForwardReference(ref str) = result[0].error { - str.starts_with("`command.foo`") - } else { - false - }); - assert!(if let Error::Constraint(ref str) = result[1].error { - str.starts_with("no references to `var`") - } else { - false - }); - assert!(if let Error::UndefinedVariable(ref str) = result[2].error { - str.starts_with("`command.biz`") - } else { - false - }); - assert!(if let Error::ForwardReference(ref str) = result[3].error { - str.starts_with("`bind.horace`") - } else { - false - }); - info!("result: {:#?}", result); - assert_eq!(result.len(), 4); - } -} +// TODO: refactor this *AFTER* we've got `bind` working again + +// use core::error; +// use std::collections::HashMap; + +// use crate::bind::{Binding, BindingInput, Command, CommandInput}; +// use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; +// use crate::util::Requiring; +// use crate::value::VariableExpanding; + +// use indexmap::IndexMap; +// #[allow(unused_imports)] +// use log::info; +// use serde::{Deserialize, Serialize}; +// use serde_wasm_bindgen; +// use toml::Spanned; +// use wasm_bindgen::prelude::*; + +// #[derive(Deserialize, Serialize, Clone, Debug)] +// pub struct DefineInput { +// pub var: Option>>>, +// pub command: Option>>, +// pub bind: Option>>, +// } + +// pub trait VariableResolver { +// fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()>; +// } + +// #[wasm_bindgen] +// #[derive(Clone, Debug, Default)] +// pub struct Define { +// #[wasm_bindgen(skip)] +// pub bind: HashMap, +// #[wasm_bindgen(skip)] +// pub command: HashMap, +// #[wasm_bindgen(skip)] +// pub var: HashMap, +// } + +// fn map_with_err(x: HashMap>, f: f) -> ResultVec> +// where +// F: FnMut(T) -> Result, +// { +// let mut errors = Vec::new(); +// let result = x +// .into_iter() +// .filter_map(|(k, v)| { +// let span = v.span(); +// let result = f(v.into_inner()).context_range(&span); +// return result.map_err(|e| errors.push(e)).ok().map(|v| (k, v)); +// }) +// .collect(); +// if errors.len() > 0 { +// return Err(errors); +// } else { +// return Ok(result); +// } +// } + +// impl Define { +// pub fn new(input: DefineInput) -> ResultVec { +// // STEP 1: resolve all definitions so that there are no interpolations of +// // `var.`, `bind.` or `command.` variables +// let mut resolved_bind = HashMap::>::new(); +// let mut resolved_command = HashMap::>::new(); +// let mut resolved_var = HashMap::::new(); +// let mut errors = Vec::new(); + +// // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they +// // must only reference previously defined variables (we've included the TOML feature +// // to preserve order, so variables can reference other variables defined within the +// // same block) + +// // TODO: do not resolve `var` values, and do not allow `{{}}` inside of `var.` values +// for def_block in input.var.into_iter().flatten() { +// for (var, mut value) in def_block.into_iter() { +// let mut var_result = value.expand_with_getter(|id| { +// if let Some((prefix, name)) = id.split_once('.') { +// if prefix == "var" { +// return Err(Error::Constraint( +// "no references to `var` within a `var` definition".into() +// ))?; +// } else if prefix == "bind" || prefix == "command" { +// return Err(Error::ForwardReference(format!( +// "`{id}`; you cannot refer to `{prefix}` values within `var` definitions" +// )))?; +// } +// } +// // TODO: refactor so that we use a unique enum type instead of +// // Some/None to signal resolution + +// // other types of variables are left unresolved +// return Ok(None); +// }); +// if let Err(ref mut errs) = var_result { +// errors.append(errs); +// } +// resolved_var.insert(var.clone(), value.get_ref().clone()); +// } +// } + +// // STEP 1b: resolve [[define.command]] blocks +// for mut def in input.command.into_iter().flatten() { +// let mut command_result = def.get_mut().expand_with_getter(|id| { +// if let Some((prefix, name)) = id.split_once('.') { +// if prefix == "var" { +// let value = resolved_var +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; +// return Ok(Some(value.clone())); +// } else if prefix == "command" { +// let val = resolved_command.get(id).ok_or_else(|| { +// Error::UndefinedVariable(format!("`{id}`")) +// })?; +// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)) +// } else if prefix == "bind" { +// return Err(Error::ForwardReference(format!( +// "`{id}`; you cannot refer to `{prefix}` values within `command` definitions" +// )))?; +// } +// } +// return Ok(None); +// }); +// if let Err(ref mut errs) = command_result { +// errors.append(errs); +// } + +// let id = def.get_ref().id.clone(); +// resolved_command.insert( +// id.require("id") +// .context_range(&def.span())? +// .get_ref() +// .clone(), +// def, +// ); +// } + +// // STEP 1c: resolve [[define.bind]] blocks +// for mut def in input.bind.into_iter().flatten() { +// let mut bind_result = def.get_mut().expand_with_getter(|id| { +// if let Some((prefix, name)) = id.split_once('.') { +// if prefix == "var" { +// let value = resolved_var +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; +// return Ok(Some(value.clone())); +// } else if prefix == "command" { +// let val = resolved_command +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; +// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); +// } else if prefix == "bind" { +// let val = resolved_bind +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; +// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); +// } +// } +// return Ok(None); +// }); +// if let Err(ref mut errs) = bind_result { +// errors.append(errs); +// } + +// let id = def.get_ref().id.clone(); +// resolved_bind.insert( +// id.require("id") +// .context_range(&def.span())? +// .get_ref() +// .clone(), +// def, +// ); +// } + +// // STEP 2: cleanup results for use in `Define` struct + +// if errors.len() > 0 { +// return Err(errors); +// } else { +// // TODO: because resolution to the Binding and Command structs does not occur until +// // later, we could, in theory end up with a *lot* of errors for the same lines, it +// // will be important to clean up the output to only show one of these errors and +// // remove the other instances; or convince our selves no such issue will arise +// let bind = resolved_bind +// .into_iter() +// .map(|(k, v)| (k, v.into_inner().without_id())) +// .collect(); +// let command = map_with_err(resolved_command, |c| Command::new(c.without_id()))?; +// return Ok(Define { +// bind, +// command, +// var: resolved_var, +// }); +// } +// } +// } + +// // NOTE: why don't we provide public access to `bind` and `command`: this avoids +// // extra implementation work, when the main use case for these two categories of +// // definitions is to make the binding file more concise; `var.` values on +// // the other hand are often used at runtime +// #[wasm_bindgen] +// impl Define { +// pub fn var(&self, key: &str) -> Result { +// let to_json = serde_wasm_bindgen::Serializer::json_compatible(); +// let value = self.var.get(key).require(format!("`{key}` field"))?; +// return match value.serialize(&to_json) { +// Ok(result) => Ok(result), +// Err(_) => unexpected("unexpected serialization error"), +// }; +// } +// } + +// // TODO: we don't actually want to resolve `var.`s as they might change during runtime +// // TODO: we need to avoid parsing expressions as variables to insert + +// impl VariableResolver for Define { +// fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()> { +// x.expand_with_getter(|var| { +// if let Some((prefix, name)) = var.split_once('.') { +// if prefix == "var" { +// return Ok(Some( +// self.var +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(var.into()))? +// .clone(), +// )); +// } else if prefix == "command" { +// let val = self +// .command +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(var.into()))? +// .clone(); +// return Ok(Some(toml::Value::try_from(val)?)); +// } else if prefix == "bind" { +// let val = self +// .bind +// .get(name) +// .ok_or_else(|| Error::UndefinedVariable(var.into()))? +// .clone(); +// return Ok(Some(toml::Value::try_from(val)?)); +// } +// } +// return Ok(None); +// })?; +// return Ok(()); +// } +// } + +// mod tests { +// // use test_log::test; + +// use super::*; +// #[test] +// fn simple_parsing() { +// let data = r#" +// [[var]] +// y = "bill" + +// [[bind]] +// id = "foo" +// key = "x" +// command = "foo" +// args = { k = 1, h = 2 } + +// [[command]] +// id = "foobar" +// command = "runCommands" +// args.commands = ["foo", "bar"] + +// [[var]] +// joe = "bob" + +// "#; + +// let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); + +// assert_eq!(result.var.get("y").unwrap().as_str().unwrap(), "bill"); +// assert_eq!(result.var.get("joe").unwrap().as_str().unwrap(), "bob"); +// let foo = result.bind.get("foo").unwrap(); +// assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); +// assert_eq!( +// foo.args +// .as_ref() +// .unwrap() +// .get_ref() +// .get("k") +// .unwrap() +// .as_integer() +// .unwrap(), +// 1 +// ); + +// assert_eq!( +// foo.args +// .as_ref() +// .unwrap() +// .get_ref() +// .get("h") +// .unwrap() +// .as_integer() +// .unwrap(), +// 2 +// ); + +// let foobar = result.command.get("foobar").unwrap(); +// assert_eq!(foobar.command, "runCommands"); +// let commands = foobar.args.get("commands").unwrap().as_array().unwrap(); +// assert_eq!(commands[0].as_str().unwrap(), "foo"); +// assert_eq!(commands[1].as_str().unwrap(), "bar"); +// } + +// #[test] +// fn parsing_resolved_variables() { +// let data = r#" +// [[var]] +// foo = 1 + +// [[var]] +// foo_string = "number-{{var.foo}}" + +// [[command]] +// id = "run_shebang" +// command = "shebang" +// args.a = 1 +// args.b = "{{var.foo_string}}" + +// [[bind]] +// id = "whole_shebang" +// key = "a" +// name = "the whole shebang" +// command = "runCommands" +// args.commands = ["{{command.run_shebang}}", "bar"] +// "#; + +// let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); +// let bind_args = result +// .bind +// .get("whole_shebang") +// .as_ref() +// .unwrap() +// .args +// .as_ref() +// .unwrap(); +// let bind_commands = bind_args +// .get_ref() +// .get("commands") +// .unwrap() +// .as_array() +// .unwrap(); +// assert_eq!( +// bind_commands[0].get("command").unwrap().as_str().unwrap(), +// "shebang" +// ); +// assert_eq!( +// bind_commands[0] +// .get("args") +// .unwrap() +// .get("b") +// .unwrap() +// .as_str() +// .unwrap(), +// "number-1" +// ); +// assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); +// } + +// #[test] +// fn parsing_order_error() { +// let data = r#" +// [[var]] +// k = "{{command.foo}}" + +// [[var]] +// a = 1 + +// [[var]] +// b = "{{var.a}}-boot" + +// [[command]] +// id = "foo" +// command = "joe" +// args.x = 1 + +// [[command]] +// id = "bar" +// command = "runCommands" +// args.commands = ["{{command.biz}}", "baz"] + +// [[command]] +// id = "biz" +// command = "bob" +// args.y = 2 +// args.x = "{{bind.horace}}" + +// [[bind]] +// id = "horace" +// key = "ctrl+k" +// command = "cursorLeft" +// args.value = "{{count}}" + +// [[bind]] +// default = "{{bind.horace}}" +// id = "bob" +// key = "ctrl+y" +// command = "cursorRight" + +// [[bind]] +// default = "{{bind.will}}" +// id = "bob" +// key = "ctrl+k" +// command = "cursorDown" +// "#; +// // TODO: add `default` key to `bind` so we can accomplish the todo below +// // TODO: test for missing `bind` +// let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); +// assert!(if let Error::ForwardReference(ref str) = result[0].error { +// str.starts_with("`command.foo`") +// } else { +// false +// }); +// assert!(if let Error::Constraint(ref str) = result[1].error { +// str.starts_with("no references to `var`") +// } else { +// false +// }); +// assert!(if let Error::UndefinedVariable(ref str) = result[2].error { +// str.starts_with("`command.biz`") +// } else { +// false +// }); +// assert!(if let Error::ForwardReference(ref str) = result[3].error { +// str.starts_with("`bind.horace`") +// } else { +// false +// }); +// info!("result: {:#?}", result); +// assert_eq!(result.len(), 4); +// } +// } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 9c3d6c8f..9afd9989 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -15,7 +15,7 @@ pub enum Error { #[error("toml parsing {0}")] TomlParsing(#[from] toml::de::Error), #[error("expression parsing {0}")] - ExpressionParsing(#[from] rhai::parser::ParseResult), + ExpressionParsing(#[from] rhai::ParseError), #[error("serializing {0}")] Serialization(#[from] toml::ser::Error), #[error("invalid {0}")] @@ -50,21 +50,24 @@ pub struct ErrorWithContext { pub contexts: Vec, } +#[wasm_bindgen] +#[derive(Debug, Clone, Error)] +#[error("first error: {}", .errors[0])] +pub struct ErrorsWithContext { + pub(crate) errors: Vec, +} + fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { let start = offsets.utf8_to_char_pos(range.start); let end = offsets.utf8_to_char_pos(range.end); CharRange { start, end } } -impl From for Vec { +impl From for ErrorsWithContext { fn from(value: ErrorWithContext) -> Self { - return vec![value]; - } -} - -impl From for Vec { - fn from(value: Error) -> Self { - return vec![value.into()]; + return ErrorsWithContext { + errors: vec![value], + }; } } @@ -74,7 +77,7 @@ impl ErrorWithContext { let mut items = Vec::with_capacity(self.contexts.len() + 1); let offsets: StringOffsets = StringOffsets::new(content); items.push(match &self.error { - Error::Parsing(toml) => ErrorReportItem { + Error::TomlParsing(toml) => ErrorReportItem { message: Some(toml.message().into()), range: toml.span().map(|r| range_to_pos(r, &offsets)), }, @@ -105,23 +108,33 @@ impl ErrorWithContext { } } +#[wasm_bindgen] +impl ErrorsWithContext { + pub fn report(&self, content: &str) -> Vec { + return self.errors.iter().map(|e| e.report(content)).collect(); + } +} + #[derive(Debug, Clone)] #[wasm_bindgen(getter_with_clone)] pub struct ErrorReport { pub items: Vec, } -fn flatten_errors(errs: impl Iterator>) -> ResultVec { - let (results, errors) = errs.partition(Result::is_ok); +pub fn flatten_errors(errs: impl Iterator>) -> ResultVec> +where + T: std::fmt::Debug, +{ + let (results, errors): (Vec<_>, Vec<_>) = errs.partition(|e| e.is_ok()); let flat_errs = errors .into_iter() - .flat_map(|x| x.unwrap_err().into_iter()) + .flat_map(|x| x.unwrap_err().errors.into_iter()) .collect::>(); if flat_errs.len() > 0 { - return Err(flat_errs); + return Err(flat_errs.into()); } else { - return Ok(results.into_iter().any(|x| x.unwrap())); + return Ok(results.into_iter().map(|x| x.unwrap()).collect()); } } @@ -171,6 +184,20 @@ impl> From for ErrorWithContext { } } +impl> From for ErrorsWithContext { + fn from(error: E) -> Self { + let error: Error = error.into(); + let error: ErrorWithContext = error.into(); + return error.into(); + } +} + +impl From> for ErrorsWithContext { + fn from(value: Vec) -> Self { + return ErrorsWithContext { errors: value }; + } +} + pub fn constrain(msg: &str) -> Result { return Err(Error::Constraint(msg.into()))?; } @@ -187,11 +214,12 @@ pub trait ErrorContext where Self: Sized, { - fn context(self, context: Context) -> Result; - fn context_str(self, context: impl Into) -> Result { + type Error; + fn context(self, context: Context) -> std::result::Result; + fn context_str(self, context: impl Into) -> std::result::Result { self.context(Context::String(context.into())) } - fn context_range(self, context: &impl Spannable) -> Result { + fn context_range(self, context: &impl Spannable) -> std::result::Result { if let Some(range) = context.range() { return self.context(Context::Range(range)); } else { @@ -223,6 +251,7 @@ impl Spannable for Range { } impl> ErrorContext for std::result::Result { + type Error = ErrorWithContext; fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), @@ -235,6 +264,7 @@ impl> ErrorContext for std::result::Result { } impl ErrorContext for Result { + type Error = ErrorWithContext; fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), @@ -249,30 +279,14 @@ impl ErrorContext for Result { } } -pub trait ErrorContexts -where - T: Sized, - Self: Sized, -{ - fn context(self, context: Context) -> ResultVec; - fn context_str(self, context: impl Into) -> ResultVec { - self.context(Context::String(context.into())) - } - fn context_range(self, context: &impl Spannable) -> ResultVec { - if let Some(range) = context.range() { - return self.context(Context::Range(range)); - } else { - return self.context(Context::Range(UNKNOWN_RANGE)); - } - } -} - -impl ErrorContexts for ResultVec { +impl ErrorContext for ResultVec { + type Error = ErrorsWithContext; fn context(self, context: Context) -> ResultVec { return match self { Ok(x) => Ok(x), Err(mut errs) => { - errs.iter_mut() + errs.errors + .iter_mut() .for_each(|e| e.contexts.push(context.clone())); Err(errs) } @@ -281,4 +295,4 @@ impl ErrorContexts for ResultVec { } pub type Result = std::result::Result; -pub type ResultVec = std::result::Result>; +pub type ResultVec = std::result::Result; diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index d1c8d319..b237133e 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,8 +1,7 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; -use crate::define::{Define, DefineInput, VariableResolver}; +// use crate::define::{Define, DefineInput, VariableResolver}; use crate::error::{ErrorContext, ErrorReport, ResultVec}; -use crate::variable::VariableExpanding; use log::info; use serde::{Deserialize, Serialize}; @@ -10,9 +9,9 @@ use toml::Spanned; use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript -#[derive(Deserialize, Serialize, Clone, Debug)] +#[derive(Deserialize, Clone, Debug)] struct KeyFileInput { - define: Option, + // define: Option, bind: Option>>, } @@ -20,123 +19,126 @@ struct KeyFileInput { #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct KeyFile { - pub define: Define, + // pub define: Define, pub bind: Vec, } -impl KeyFile { - fn new(mut input: KeyFileInput) -> ResultVec { - let mut errors = Vec::new(); - - let define = input - .define - .map(|define| { - Define::new(define) - .map_err(|es| { - for e in es.into_iter() { - errors.push(e); - } - }) - .ok() - }) - .flatten() - .unwrap_or_default(); - - // TODO: expand each define using the other known definitions - // (with some limit on the number of iterations to resolved) - define.resolve_variables(&mut input.bind)?; - - let bind = input - .bind - .map(|bindings| { - return bindings - .into_iter() - .filter_map(|b| { - let span = b.span(); - let result = Binding::new(b.into_inner()).context_range(&span); - result.map_err(|e| errors.push(e)).ok() - }) - .collect(); - }) - .unwrap_or_default(); - - if errors.len() == 0 { - return Ok(KeyFile { bind, define }); - } else { - return Err(errors); - } - } -} - -#[wasm_bindgen(getter_with_clone)] -pub struct KeyFileResult { - pub file: Option, - pub errors: Option>, -} - -#[wasm_bindgen] -pub fn parse_string(file_content: &str) -> KeyFileResult { - return match parse_string_helper(file_content) { - Ok(result) => KeyFileResult { - file: Some(result), - errors: None, - }, - Err(err) => KeyFileResult { - file: None, - errors: Some(err.iter().map(|e| e.report(file_content)).collect()), - }, - }; -} - -fn parse_string_helper(file_content: &str) -> ResultVec { - let parsed = toml::from_str::(file_content); - return match parsed { - Ok(input) => KeyFile::new(input), - Err(err) => Err(vec![err.into()]), - }; -} - -#[cfg(test)] -mod tests { - use super::*; - use test_log::test; - - #[test] - fn parse_example() { - let data = r#" - [[define.var]] - foo = "bar" - - [[bind]] - key = "l" - mode = "normal" - command = "cursorRight" - - [[bind]] - key = "h" - model = "normal" - command = "cursorLeft" - "#; - - let result = parse_string(data); - let items = result.file.as_ref().unwrap(); - - assert_eq!(items.bind[0].key, "l"); - assert_eq!(items.bind[0].commands[0].command, "cursorRight"); - assert_eq!(items.bind[1].key, "h"); - assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); - - // assert_eq!( - // items - // .define - // .var - // .as_ref() - // .unwrap() - // .get("foo") - // .unwrap() - // .as_str() - // .unwrap(), - // "bar" - // ) - } -} +// impl KeyFile { +// fn new(mut input: KeyFileInput) -> ResultVec { +// let mut errors = Vec::new(); + +// // let define = input +// // .define +// // .map(|define| { +// // Define::new(define) +// // .map_err(|es| { +// // for e in es.into_iter() { +// // errors.push(e); +// // } +// // }) +// // .ok() +// // }) +// // .flatten() +// // .unwrap_or_default(); + +// // TODO: expand each define using the other known definitions +// // (with some limit on the number of iterations to resolved) +// // define.resolve_variables(&mut input.bind)?; + +// let bind = input +// .bind +// .map(|bindings| { +// return bindings +// .into_iter() +// .filter_map(|b| { +// let span = b.span(); +// let result = Binding::new(b.into_inner()).context_range(&span); +// result.map_err(|e| errors.push(e)).ok() +// }) +// .collect(); +// }) +// .unwrap_or_default(); + +// if errors.len() == 0 { +// return Ok(KeyFile { +// bind, +// // define +// }); +// } else { +// return Err(errors); +// } +// } +// } + +// #[wasm_bindgen(getter_with_clone)] +// pub struct KeyFileResult { +// pub file: Option, +// pub errors: Option>, +// } + +// #[wasm_bindgen] +// pub fn parse_string(file_content: &str) -> KeyFileResult { +// return match parse_string_helper(file_content) { +// Ok(result) => KeyFileResult { +// file: Some(result), +// errors: None, +// }, +// Err(err) => KeyFileResult { +// file: None, +// errors: Some(err.iter().map(|e| e.report(file_content)).collect()), +// }, +// }; +// } + +// fn parse_string_helper(file_content: &str) -> ResultVec { +// let parsed = toml::from_str::(file_content); +// return match parsed { +// Ok(input) => KeyFile::new(input), +// Err(err) => Err(vec![err.into()]), +// }; +// } + +// #[cfg(test)] +// mod tests { +// use super::*; +// // use test_log::test; + +// #[test] +// fn parse_example() { +// let data = r#" +// [[define.var]] +// foo = "bar" + +// [[bind]] +// key = "l" +// mode = "normal" +// command = "cursorRight" + +// [[bind]] +// key = "h" +// model = "normal" +// command = "cursorLeft" +// "#; + +// let result = parse_string(data); +// let items = result.file.as_ref().unwrap(); + +// assert_eq!(items.bind[0].key, "l"); +// assert_eq!(items.bind[0].commands[0].command, "cursorRight"); +// assert_eq!(items.bind[1].key, "h"); +// assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); + +// // assert_eq!( +// // items +// // .define +// // .var +// // .as_ref() +// // .unwrap() +// // .get("foo") +// // .unwrap() +// // .as_str() +// // .unwrap(), +// // "bar" +// // ) +// } +// } diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index a79e3595..1a4b2adf 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,7 +1,7 @@ // error reporting pub mod error; mod util; -mod variable; +mod value; // [[bind]] level parsing mod bind; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index c8b454e1..f11343f8 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,8 +1,6 @@ -use crate::{ - bind::UNKNOWN_RANGE, - error::{Error, ErrorContext, ErrorWithContext, Result}, -}; +use crate::error::{Error, ErrorContext, ErrorWithContext, Result}; +use indexmap::IndexMap; use log::info; use serde::{Deserialize, Serialize}; use toml::{Spanned, Value}; @@ -36,6 +34,22 @@ impl Merging for toml::Table { } } +impl Merging for IndexMap { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, mut new: Self) -> Self { + for (k, v) in self { + if new.contains_key(&k) { + new[&k] = v.merge(new[&k].clone()); + } else { + new.insert(k, v); + } + } + return new; + } +} + impl Merging for Spanned { fn merge(self, new: Self) -> Self { return Spanned::new(self.span(), self.into_inner().merge(new.into_inner())); @@ -174,6 +188,16 @@ impl Required { } } + pub fn map(self, f: F) -> Required + where + F: Fn(T) -> R, + { + match self { + Required::DefaultValue => Required::DefaultValue, + Required::Value(x) => Required::Value(f(x)), + } + } + pub fn or(self, new: Self) -> Self { return match new { Required::Value(new_val) => match self { diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs new file mode 100644 index 00000000..3951be1b --- /dev/null +++ b/src/rust/parsing/src/value.rs @@ -0,0 +1,449 @@ +use std::any::TypeId; +use std::collections::VecDeque; +use std::error; +use std::io; +use std::io::Write; + +use js_sys::Boolean; +#[allow(unused_imports)] +use log::info; + +use indexmap::IndexMap; +use lazy_static::lazy_static; +use regex::Regex; +use rhai::{AST, CustomType, Engine}; +use serde::{Deserialize, Serialize}; +use toml::Spanned; +use toml::ser::Buffer; + +use crate::error::{ + Error, ErrorContext, ErrorWithContext, ErrorsWithContext, Result, ResultVec, flatten_errors, +}; +use crate::util::{Merging, Plural, Required, Resolving}; + +// TODO: implement Expanding type + +pub enum ExpandResult { + Expanded(Value), + Deferred, +} + +// TODO: implement Float / Integer, and deal with regularizing that +// to float64 only when we serialize to JSON (but still enforce the +// boundary on integers in the same place we do now) +#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)] +#[serde(try_from = "toml::Value")] +pub enum Value { + Integer(i32), + Float(f64), + String(String), + Boolean(bool), + Array(Vec), + Table(IndexMap), + Interp(Vec), + Expression(String), +} + +lazy_static! { + pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*?)\}\}").unwrap(); +} + +impl TryFrom for Value { + type Error = ErrorsWithContext; + fn try_from(value: toml::Value) -> ResultVec { + return Ok(match value { + toml::Value::Boolean(x) => Value::Boolean(x), + toml::Value::Float(x) => Value::Float(x), + toml::Value::Integer(x) => Value::Integer({ + if x > (std::f64::MAX as i64) || x < (std::f64::MIN as i64) { + return Err(Error::Constraint(format!( + "{x} cannot be expressed as a 64-bit floating point number." + )) + .into()); + } else { + x.clone() as i32 + } + }), + toml::Value::Datetime(x) => Value::String(x.to_string()), + toml::Value::String(x) => string_to_expression(x), + toml::Value::Array(toml_values) => { + let values = flatten_errors(toml_values.into_iter().map(|x| { + return Ok(x.try_into::()?); + }))?; + Value::Array(values) + } + toml::Value::Table(toml_kv) => { + let kv = flatten_errors( + toml_kv + .into_iter() + .map(|(k, v)| Ok((k, v.try_into::()?))), + )?; + Value::Table(kv.into_iter().collect()) + } + }); + } +} + +fn string_to_expression(x: String) -> Value { + let exprs = EXPRESSION.captures_iter(&x); + // there are multiple expressions interpolated into the string + let mut interps = Vec::new(); + let mut last_match = 0..0; + // push rest + for expr in exprs { + let r = expr.get(0).expect("full match").range(); + if r.len() == x.len() { + return Value::Expression(expr.get(1).expect("variable name").as_str().into()); + } + if last_match.end < r.start { + interps.push(Value::String(x[last_match.end..r.start].into())); + } + last_match = r; + + let var_str = expr.get(1).expect("variable name").as_str(); + interps.push(Value::Expression(var_str.into())); + } + if last_match.start == 0 && last_match.end == 0 { + return Value::String(x); + } + if last_match.end < x.len() { + interps.push(Value::String(x[last_match.end..].into())); + } + return Value::Interp(interps); +} + +impl Merging for Value { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, new: Self) -> Self { + match new { + Value::Array(new_values) => match self { + Value::Array(old_values) => { + let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); + let mut new_iter = new_values.into_iter(); + let mut old_iter = old_values.into_iter(); + loop { + let new_item = new_iter.next(); + let old_item = old_iter.next(); + if new_item.is_none() && old_item.is_none() { + break; + } + result.push(old_item.merge(new_item).unwrap()); + } + Value::Array(result) + } + _ => Value::Array(new_values), + }, + Value::Table(new_kv) => match self { + Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), + _ => Value::Table(new_kv), + }, + _ => new, + } + } +} + +pub trait Expanding { + fn map_expressions(self, f: &F) -> ResultVec + where + Self: Sized, + F: Fn(String) -> Result; + + fn is_constant(&self) -> bool; + fn require_constant(&self) -> ResultVec<()> + where + Self: Sized + Clone, + { + self.clone().map_expressions(&|e| { + Err(Error::Unresolved(format!("Unresolved expression {e}")).into()) + })?; + return Ok(()); + } +} + +impl Expanding for IndexMap { + fn is_constant(&self) -> bool { + self.values().all(|v| v.is_constant()) + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + return Ok(flatten_errors( + self.into_iter() + .map(|(k, v)| Ok((k, v.map_expressions(f)?))), + )? + .into_iter() + .collect()); + } +} + +impl Expanding for Value { + fn is_constant(&self) -> bool { + match self { + Value::Expression(_) => false, + Value::Interp(_) => false, + Value::Array(items) => items.iter().all(|it| it.is_constant()), + Value::Table(kv) => kv.values().all(|it| it.is_constant()), + Value::Boolean(_) | Value::Float(_) | Value::Integer(_) | Value::String(_) => true, + } + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + // XXX: we could optimize by pruning constant branches + return Ok(match self { + Value::Expression(x) => f(x)?, + Value::Interp(interps) => { + let value: Vec = interps.map_expressions(f)?.into(); + if value.is_constant() { + let strs = flatten_errors(value.into_iter().map(|v| match v { + Value::String(x) => Ok(x), + obj @ _ => { + let toml: toml::Value = obj.into(); + let mut result = String::new(); + toml.serialize(toml::ser::ValueSerializer::new(&mut result))?; + Ok(result) + } + }))?; + Value::String(strs.join("")) + } else { + Value::Interp(value) + } + } + Value::Array(items) => Value::Array(items.map_expressions(f)?), + Value::Table(kv) => Value::Table(kv.map_expressions(f)?), + literal @ (Value::Boolean(_) + | Value::Float(_) + | Value::Integer(_) + | Value::String(_)) => literal, + }); + } +} + +impl From for toml::Value { + fn from(value: Value) -> toml::Value { + return match value { + Value::Expression(x) => panic!("Unresolved expression {x}"), + Value::Interp(interps) => panic!("Unresolved interpolation {interps:?}"), + Value::Array(items) => { + let new_items = items.into_iter().map(|it| it.into()).collect(); + toml::Value::Array(new_items) + } + Value::Table(kv) => { + let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); + toml::Value::Table(new_kv) + } + Value::Boolean(x) => toml::Value::Boolean(x), + Value::Float(x) => toml::Value::Float(x), + Value::Integer(x) => toml::Value::Integer(x as i64), + Value::String(x) => toml::Value::String(x), + }; + } +} + +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] +#[serde(try_from = "toml::Value")] +pub enum TypedValue +where + T: Serialize + std::fmt::Debug, +{ + Variable(Value), + Constant(T), +} + +impl<'e, T> TryFrom for TypedValue +where + T: Deserialize<'e> + Serialize + std::fmt::Debug, +{ + type Error = ErrorsWithContext; + fn try_from(value: toml::Value) -> ResultVec> { + io::stdout().flush().unwrap(); + + let val: Value = value.try_into()?; + io::stdout().flush().unwrap(); + return match val.require_constant() { + Err(_) => Ok(TypedValue::Variable(val)), + Ok(_) => { + let toml: toml::Value = val.into(); + let typed_value = toml.try_into(); + Ok(TypedValue::Constant(typed_value?)) + } + }; + } +} + +impl Expanding for TypedValue +where + T: From>, +{ + fn is_constant(&self) -> bool { + match self { + TypedValue::Constant(_) => true, + TypedValue::Variable(_) => false, + } + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + return Ok(match self { + TypedValue::Variable(v) => { + let result = v.map_expressions(f)?; + if result.is_constant() { + TypedValue::Constant(TypedValue::Variable(result).into()) + } else { + TypedValue::Variable(result) + } + } + TypedValue::Constant(x) => TypedValue::Constant(x), + }); + } +} + +impl From> for i64 { + fn from(value: TypedValue) -> Self { + return match value { + TypedValue::Constant(x) => x, + TypedValue::Variable(value) => { + let toml: toml::Value = value.into(); + toml.try_into().expect("proper typing") + } + }; + } +} + +impl From> for f64 { + fn from(value: TypedValue) -> Self { + return match value { + TypedValue::Constant(x) => x, + TypedValue::Variable(value) => { + let toml: toml::Value = value.into(); + toml.try_into().expect("proper typing") + } + }; + } +} + +impl From> for String { + fn from(value: TypedValue) -> Self { + return match value { + TypedValue::Constant(x) => x, + TypedValue::Variable(value) => { + let toml: toml::Value = value.into(); + toml.try_into().expect("proper typing") + } + }; + } +} + +impl From> for bool { + fn from(value: TypedValue) -> Self { + return match value { + TypedValue::Constant(x) => x, + TypedValue::Variable(value) => { + let toml: toml::Value = value.into(); + toml.try_into().expect("proper typing") + } + }; + } +} + +impl Merging for TypedValue { + fn coalesce(self, new: Self) -> Self { + return new; + } + + fn merge(self, new: Self) -> Self { + return new; + } +} + +// expansion for other kinds of types +impl Expanding for Spanned { + fn is_constant(&self) -> bool { + self.as_ref().is_constant() + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + let span = self.span(); + Ok(Spanned::new( + span.clone(), + self.into_inner().map_expressions(f).context_range(&span)?, + )) + } +} + +impl Expanding for Vec { + fn is_constant(&self) -> bool { + self.iter().all(|x| x.is_constant()) + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + Ok(flatten_errors( + self.into_iter().map(|x| x.map_expressions(f)), + )?) + } +} + +impl Expanding for Plural { + fn is_constant(&self) -> bool { + match self { + Plural::Zero => true, + Plural::One(x) => x.is_constant(), + Plural::Many(xs) => xs.iter().all(|x| x.is_constant()), + } + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + Ok(match self { + Plural::Zero => self, + Plural::One(x) => Plural::One(x.map_expressions(f)?), + Plural::Many(items) => Plural::Many(items.map_expressions(f)?), + }) + } +} + +impl Expanding for Required { + fn is_constant(&self) -> bool { + match self { + Required::DefaultValue => true, + Required::Value(x) => x.is_constant(), + } + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + return Ok(match self { + Required::DefaultValue => self, + Required::Value(x) => Required::Value(x.map_expressions(f)?), + }); + } +} + +impl Expanding for Option { + fn is_constant(&self) -> bool { + match self { + None => true, + Some(x) => x.is_constant(), + } + } + fn map_expressions(self, f: &F) -> ResultVec + where + F: Fn(String) -> Result, + { + return Ok(match self { + None => self, + Some(x) => Some(x.map_expressions(f)?), + }); + } +} diff --git a/src/rust/parsing/src/variable.rs b/src/rust/parsing/src/variable.rs deleted file mode 100644 index d15bd2f1..00000000 --- a/src/rust/parsing/src/variable.rs +++ /dev/null @@ -1,495 +0,0 @@ -use std::error; - -use crate::error::{Error, ErrorContexts, ErrorWithContext, Result, ResultVec}; -use crate::util::{Merging, Plural, Required, Resolving}; - -use js_sys::Boolean; -#[allow(unused_imports)] -use log::info; - -use lazy_static::lazy_static; -use regex::Regex; -use rhai::{CustomType, Engine, AST}; -use serde::{Deserialize, Serialize}; -use toml::Spanned; - -// TODO: implement Expanding type - -pub enum ExpandResult { - Expanded(Value), - Deferred, -} - -pub enum Interp { - Constant(String), - Expression(Expression), -} - -pub enum Value { - Number(f64), - String(String), - Boolean(bool), - Array(Vec), - Table(IndexMap), - Interp(Vec), - Expression(Expression), -} - -pub enum Expression { - Variable(String), - Statement(String), -} - -lazy_static! { - pub static ref IDENTIFIER_CHAIN: Regex = Regex::new(r"((\s*[\w--\d]\w*\.)*[\w--\d]\w*)\s*\}\}").unwrap(); - pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*)\}\}").unwrap(); -} - -impl TryFrom for Value { - type Error = Vec; - fn try_from(value: toml::Value) -> ResultVec { - return Ok(match value { - toml::Value::Boolean(x) => Value::Boolean(x), - toml::Value::Float(x) => Value::Number(x), - toml::Value::Integer(x) => Value::Number(x.try_into().context("{x} cannot be expressed as a 64-bit floating-point number.")?), - toml::Value::Datetime(x) => Value::String(x.into()), - toml::Value::String(x) => string_to_expression(x)?, - toml::Value::Array(toml_values) => { - let values = flatten_errors(toml_values.iter().map(|x| Value::new(x, engine, expressions)))?; - is_constant = values.all(|x| x.is_constant); - Value::Array(values) - } - toml::Value::Table(toml_kv) => { - let kv = flatten_errors(toml_kv.iter().map(|(k, v)| Ok((k, Value::new(v, engine, expressions)?))))?; - is_constant = kv.all(|(k,v)| v.is_constant); - Value::Table(IndexMap::new(kv)) - } - }); - } -} - -impl Value { - fn expressions(self: Value, expressions: &mut Vec) { - match self { - Value::Expression(x) => expressions.push(x), - Value::Interp(interps) => iterps.for_each(|iterp| { - match inter { - Interp::Expression(x) => expressions.push(x), - _ => (), - } - }), - Value::Array(items) => items.iter().for_each(|item| item.expressions(expressions)), - Value::Table(kv) => kv.values().for_each(|val| val.expressions(expressions)), - _ => (), - } - } -} - -// TODO: function to extract expressions into a vector -// TODO: functions -// - by replacing all observations of a given expression -// - by checking names and resolving or erroring (e.g. for `bind.` and `command.`) -// - by running an expression engine for each expression -// TODO: function to translate resolved expressions into toml::Value and JSON - -struct TypedValue { - value: Value -} - -impl TryInto for TypedValue { - type Error = Error; - fn try_into(self) -> Result { - return match self.value { - Value::Boolean(x) => Ok(x), - Expression(str, i) => Err(Error::Unresolved("expression")), - _ => Err(Error::Constraint("boolean value")) - } - } -} - -impl TryInto for TypedValue { - type Error = Error; - fn try_into(self) -> Result { - return match self.value { - Value::Number(x) => Ok(x), - Expression(str, i) => Err(Error::Unresolved("expression")), - _ => Err(Error::Constraint("number")) - } - } -} - -impl TryInto for TypedValue { - type Error = Error; - fn try_into(self) -> Result { - return match self.value { - Value::String(x) => Ok(x), - Expression(str, i) => Err(Error::Unresolved("expression")), - _ => Err(Error::Constraint("string")) - } - } -} - -// impl TryInto for TypedValue -// where T: Deserialize, -// { -// type Error = Error; -// fn try_into(self) -> Result { -// let toml = toml::Value::try_from(self)?; -// let val = Value::new() -// } -// } - -fn expand_variables(expander: F, expressions: &mut Vec) -> ResultVec<()> - where F: FnMut(&str) -> Result { - let errors = Vec::new(); - for i in 0..expressions.len() { - match expressions[i] { - Expression::Variable(str) => { - match expander(str) { - Err(e) => errors.push(e), - Ok(result) => if ExpandResult::Expanded(val) = result { - expressions[i] = Expression::Literal(val) - } - } - } - _ => () - } - - if errors.len() > 0 { - return Err(errors); - } else { - return Ok(()); - } - } -} - -impl Expression { - fn new(expr: &str) -> Result { - // XXX: array indices are more fragile to mutation; for now this seems okay - // but I could also see using a hash of the expression string to index - if IDENTIFIER_CHAIN.is_match(expr) { - return Expression::Variable(expr_str); - } else { - return Expression::Statement(expr_str); - } - } -} - -fn string_to_expression( - x: String, -) -> Value { - let exprs = EXPRESSION.captures_iter(x); - if exprs.first().get(0).expect("full_match").len() == x.len() { - return Value::Expression(Expression::new(exprs.first().get(1).expect("expression body").as_str())); - } else { // there are multiple expressions interpolated into the string - let mut interps = Vec::new(); - let mut last_match = 0..0; - for expr in exprs { - let r = expr.get(0).expect("full match").range(); - interps.push(InterpItem::Constant(&self[last_match.end..r.start])); - last_match = r; - - let var_str = expr.get(1).expect("variable name").as_str(); - interps.push(InterpItem::Expression(Expression::new(var_str))); - } - if last_match.start == 0 && last_match.end == 0 { - return (true, Value::String(x)); - } - if last_match.end < self.len() { - interps.push(InterpItem::Constant(&self[last_match.end..])); - } - return Value::Interp(interps); - } -} - -// TODO: implement methods to serialize to the values to json objects / toml values - -// TODO: `expand_with_getter` API isn't going to work -// since Rhai expects a scope object with all defined objects - -pub trait Expanding { - fn expand(&mut self, context: &impl Index) -> ResultVec; - fn expand_value(&mut self, var: &str, value: &Value) -> ResultVec<()> { - self.expand([(var, value)]); - } -} - -impl Expanding for Spanned { - fn expand(&mut self, context: &impl Index) -> ResultVec { - return self .get_mut().expand(context).context_range(&self.span()); - } -} - -impl Expanding for Vec { - fn expand(&mut self, context: &impl Index) -> ResultVec { - return flatten_errors(self.iter_mut().map(|x| x.expand(context))); - } -} - -impl Expanding for Plural { - fn expand(&mut self, context: &impl Index) -> ResultVec { - match self { - Plural::Zero => return Ok(true), - Plural::One(x) => return x.expand(context), - Plural::Many(items) => { - return flatten_errors( - items - .iter_mut() - .map(|v| v.expand(context)), - ); - } - } - } -} - -impl Expanding for Required { - fn expand(&mut self, context: &impl Index) -> ResultVec { - Ok(match self { - Required::DefaultValue => true, - Required::Value(x) => x.expand(context)?, - }) - } -} - -impl Expanding for IndexMap { - fn expand(&mut self, context: &impl Index) -> ResultVec { - return flatten_errors( - self.values_mut() - .map(|x| x.expand(context)), - ); - } -} - -impl Expanding for Value { - fn expand(&mut self, context: &impl Index) -> ResultVec { - if self.is_constant { - return Ok(()); - } - let (expansion, is_now_constant) = match self.data { - Value::Number(_) | Value::String(_) | Value::Boolean(_) => (self.data, true), - Value::Array(ref mut items) => (self.data, items.expand(context)), - Value::Table(ref mut kv) => (self.data, kv.expand(context)), - // TODO: we need to think on this more since we want to error - // or differ expansion depending on the name, so the context - // API doesn't quite work - Value::Variable(name) => match context[&name] { - ExpandResult::Deferred => (self.data, false), - ExpandResult::Expanded(val) => (val, false), - }, - Value::StringInterp(vals) => (self.data, vals.expand(context)), - Value::Expression(ast) => match expand_expression(ast, context) { - ExpandResult::Deferred => (self.data, false), - ExpandResult::Expanded() - } - toml::Value::Array(items) => { - let mut errors = Vec::::new(); - for i in 0..items.len() { - match expand_to_value(&mut items[i], getter.clone()) { - Err(ref mut err) => { - errors.append(err); - } - Ok(value) => { - items[i] = value; - } - } - } - if errors.len() > 0 { - return Err(errors); - } else { - return Ok(()); - } - } - toml::Value::Table(kv) => { - return kv.expand(context); - } - toml::Value::Boolean(_) | toml::Value::Datetime(_) => return Ok(()), - toml::Value::Float(_) | toml::Value::Integer(_) => return Ok(()), - } - } -} - -impl Expanding for Option { - fn expand_with_getter(&mut self, getter: F) -> ResultVec - where - F: Fn(&str) -> Result, - F: Clone, - { - Ok(match self { - Some(v) => v.expand_with_getter(getter)?, - None => (), - }) - } -} - -pub(crate) trait As { - fn astype(&self) -> Result; -} - -impl As for toml::Value { - fn astype(&self) -> Result { - Ok(self - .as_str() - .map(|s| s.into()) - .ok_or_else(|| Error::Constraint(format!("type String, found {}", self)))?) - } -} - -impl As for toml::Value { - fn astype(&self) -> Result { - Ok(self - .as_bool() - .ok_or_else(|| Error::Constraint(format!("type bool, found {}", self)))?) - } -} - -impl As for toml::Value { - fn astype(&self) -> Result { - Ok(self - .as_integer() - .ok_or_else(|| Error::Constraint(format!("type i64, found {}", self)))?) - } -} - -impl As for toml::Value { - fn astype(&self) -> Result { - Ok(self - .as_float() - .ok_or_else(|| Error::Constraint(format!("type f64, found {}", self)))?) - } -} - -impl As for T -where - T: Clone, -{ - fn astype(&self) -> Result { - Ok(self.clone()) - } -} - -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] -#[serde(transparent)] -pub struct TypedValue(TypedValueEnum) -where - toml::Value: As; - -#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] -#[serde(untagged)] -pub enum TypedValueEnum -where - toml::Value: As, -{ - Literal(T), - Variable(String), -} - -impl TypedValue -where - toml::TypedValue: As, -{ - pub fn var(x: String) -> Self { - return TypedValue(TypedValueEnum::Variable(x)); - } -} - -impl Expanding for TypedValue -where - toml::Value: As, -{ - fn expand(&mut self, context: &impl Index) -> ResultVec { - match &self.0 { - TypedValueEnum::Literal(_) => return Ok(()), - TypedValueEnum::Variable(name) => { - // TODO: use `try_from` to extract name during parse time - // rather than expansion time - let value = match getter(name)? { - Some(x) => x, - None => return Ok(()), - }; - self.0 = TypedValueEnum::Literal(As::::astype(&value)?); - return Ok(()); - } - }; - } -} - -impl Merging for TypeValue -where - toml::Value: As, -{ - fn coalesce(self, new: Self) -> Self { - return new; - } - - fn merge(self, new: Self) -> Self { - return new; - } -} - -impl TypedValue -where - toml::Value: As, -{ - pub fn unwrap(self) -> T { - return match self.0 { - ValueEnum::Literal(x) => x, - ValueEnum::Variable(_) => panic!("Expected literal value"), - }; - } -} - -impl Resolving for TypedValue -where - toml::Value: As, -{ - fn resolve(self, name: impl Into) -> Result { - return match self.0 { - TypedValueEnum::Literal(x) => Ok(x), - TypedValueEnum::Variable(str) => { - Err(Error::Unresolved(format!("{str} for {}", name.into())))? - } - }; - } -} - -impl Expanding for String { - fn expand_with_getter(&mut self, getter: F) -> ResultVec - where - F: Fn(&str) -> Result, - F: Clone, - { - let mut result = String::new(); - let mut last_match = 0..0; - for m in VAR_STRING.find_iter(self) { - let r = m.range(); - - result.push_str(&self[last_match.end..r.start]); - let var = &self[(r.start + 2)..(r.end - 2)]; - let value = match getter(&var)? { - Some(x) => x, - None => { - result.push_str(&self[r.start..r.end]); - last_match = r; - continue; - } - }; - let output = match value { - toml::Value::String(x) => x.clone(), - _ => value.to_string(), - }; - result.push_str(&output); - last_match = r; - } - if last_match.start == 0 && last_match.end == 0 { - return Ok(()); - } - - if last_match.end < self.len() { - result.push_str(&self[last_match.end..]) - } - self.clear(); - self.push_str(&result); - - return Ok(()); - } -} From f323d8159e369681ed07b15f64fb2df34927a4e0 Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 31 Aug 2025 00:17:11 -0400 Subject: [PATCH 36/79] wip debug binding resolution Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 54 ++--- src/rust/parsing/src/bind.rs | 252 +++++++++++++----------- src/rust/parsing/src/bind/validation.rs | 9 +- src/rust/parsing/src/util.rs | 82 ++++---- src/rust/parsing/src/value.rs | 48 +++-- 5 files changed, 246 insertions(+), 199 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 30688462..0ab579d0 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#ee2fcb", + "statusBarItem.warningBackground": "#162fd0", "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#ee2fcb", + "statusBarItem.warningHoverBackground": "#162fd0", "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#fb3cd8", + "statusBarItem.remoteBackground": "#233cdd", "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#ff49e5", + "statusBarItem.remoteHoverBackground": "#3049ea", "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#ee2fcb", + "statusBar.background": "#162fd0", "statusBar.foreground": "#ffffff", - "statusBar.border": "#ee2fcb", - "statusBar.debuggingBackground": "#ee2fcb", + "statusBar.border": "#162fd0", + "statusBar.debuggingBackground": "#162fd0", "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#ee2fcb", - "statusBar.noFolderBackground": "#ee2fcb", + "statusBar.debuggingBorder": "#162fd0", + "statusBar.noFolderBackground": "#162fd0", "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#ee2fcb", - "statusBar.prominentBackground": "#ee2fcb", + "statusBar.noFolderBorder": "#162fd0", + "statusBar.prominentBackground": "#162fd0", "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#ee2fcb", + "statusBar.prominentHoverBackground": "#162fd0", "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#ee2fcb99", - "progressBar.background": "#ee2fcb", - "textLink.foreground": "#ff6fff", - "textLink.activeForeground": "#ff7cff", - "selection.background": "#e122be", - "list.highlightForeground": "#ee2fcb", - "list.focusAndSelectionOutline": "#ee2fcb99", - "button.background": "#ee2fcb", + "focusBorder": "#162fd099", + "progressBar.background": "#162fd0", + "textLink.foreground": "#566fff", + "textLink.activeForeground": "#637cff", + "selection.background": "#0922c3", + "list.highlightForeground": "#162fd0", + "list.focusAndSelectionOutline": "#162fd099", + "button.background": "#162fd0", "button.foreground": "#ffffff", - "button.hoverBackground": "#fb3cd8", - "tab.activeBorderTop": "#fb3cd8", - "pickerGroup.foreground": "#fb3cd8", - "list.activeSelectionBackground": "#ee2fcb4d", - "panelTitle.activeBorder": "#fb3cd8", - "activityBar.activeBorder": "#ee2fcb", + "button.hoverBackground": "#233cdd", + "tab.activeBorderTop": "#233cdd", + "pickerGroup.foreground": "#233cdd", + "list.activeSelectionBackground": "#162fd04d", + "panelTitle.activeBorder": "#233cdd", + "activityBar.activeBorder": "#162fd0", "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#ee2fcb" + "activityBarBadge.background": "#162fd0" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index ea5755d6..a86a3d94 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -44,6 +44,7 @@ fn span_required_default() -> Spanned> { fn span_plural_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Plural::Zero); } + /** * @bindingField bind * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` @@ -362,7 +363,7 @@ impl CommandInput { #[wasm_bindgen(getter_with_clone)] #[derive(Clone, Debug, Serialize)] pub struct Command { - pub(crate) command: TypedValue, + pub(crate) command: String, pub(crate) args: Value, } @@ -380,12 +381,12 @@ impl Command { } impl Command { - pub fn new(input: CommandInput) -> Result { + pub fn new(input: CommandInput) -> ResultVec { if let Some(_) = input.id { - return reserved("id"); + return reserved("id")?; } return Ok(Command { - command: input.command.into_inner().resolve("`command` field")?, + command: input.command.resolve("`command` field")?, args: match input.args { Some(x) => x.into_inner(), None => Value::Table(IndexMap::new()), @@ -401,9 +402,9 @@ impl Command { pub struct Binding { pub key: String, pub commands: Vec, - pub when: Vec, + pub when: Option, pub mode: Vec, - pub priority: i64, + pub priority: f64, pub prefixes: Vec, pub finalKey: bool, pub(crate) repeat: Option>, @@ -436,7 +437,7 @@ impl BindingInput { return false; } - pub fn expand_foreach(mut self) -> ResultVec> { + pub fn expand_foreach(self) -> ResultVec> { if self.has_foreach() { let foreach = expand_keys(self.foreach.clone().unwrap())?; foreach.require_constant().context_str( @@ -444,7 +445,9 @@ impl BindingInput { )?; let values = expand_foreach_values(foreach).into_iter().map(|values| { - self.clone() + let mut result = self.clone(); + result.foreach = None; + result .map_expressions(&|x| { Ok(values .get(&x) @@ -603,118 +606,131 @@ impl Expanding for BindingInput { } } -fn regularize_commands(input: BindingInput) -> ResultVec<(BindingInput, Vec)> { - return Err(Error::Unexpected("TODO"))?; - // // TODO: this works with TOML values, need to figure out how to - // // work with Value's since some of them can be expressions - // let command_value: toml::Value = input.command.into(); - // let command = command_value.get_ref().clone().resolve("`command` field")?; - // let args = input.args.clone(); - // if command == "runCommands" { - // let spanned = args - // .require("`args` field") - // .context_str("`runCommands` must have `args` field") - // .context_range(&command_value)?; - // let args_pos = spanned.span(); - // let args = spanned.into_inner(); - // let commands = args - // .get("commands") - // .require("`commands` field") - // .context_str("`runCommands.args` must have a `commands` fields") - // .context_range(&args_pos)?; - // let commands = commands.as_array().require("`commands` to be an array")?; - // let mut command_result = Vec::with_capacity(commands.len()); - // for command in commands { - // let (command, args) = match command { - // Value::String(str) => (str.to_owned(), toml::Table::new()), - // Value::Table(kv) => { - // let command_name = kv - // .get("command") - // .require("`command` field")? - // .as_str() - // .require("`command` to be string") - // .context_range(&args_pos)? - // .to_owned(); - // let args = command - // .get("args") - // .require("`args` field")? - // .as_table() - // .require("`args` to be a table")? - // .to_owned(); - // (command_name, args) - // } - // _ => { - // return constrain( - // "`commands` to be an array that includes objects and strings only", - // )?; - // } - // }; - - // command_result.push(Command { command, args }) - // } - - // return Ok((input, command_result)); - // } else { - // return Ok(( - // input, - // vec![Command { - // command, - // args: match args { - // Some(x) => x.into_inner(), - // None => toml::Table::new(), - // }, - // }], - // )); - // } +fn regularize_commands(input: &BindingInput) -> ResultVec> { + let command: String = input.clone().command.resolve("`command` field")?; + if command != "runCommands" { + let commands = vec![Command { + command, + args: match &input.args { + None => Value::Table(IndexMap::new()), + Some(spanned) => spanned.as_ref().clone(), + }, + }]; + return Ok(commands); + } else { + let spanned = input + .args + .as_ref() + .ok_or_else(|| Error::Constraint("`runCommands` must have `args` field".to_string()))?; + let args_pos = spanned.span(); + let args = spanned.as_ref().to_owned(); + let commands = match args { + Value::Table(kv) => kv + .get("commands") + .ok_or_else(|| { + Error::Constraint("`runCommands` must have `args.commands` field".into()) + })? + .clone(), + _ => Err(Error::Validation( + "Expected `args` to be an object with `commands` field".to_string(), + ))?, + }; + let command_vec = match commands { + Value::Array(items) => items, + _ => Err(Error::Validation( + "Expected `args.commands` of `runCommands` to \ + be a vector of commands to run." + .to_string(), + ))?, + }; + + let mut command_result = Vec::with_capacity(command_vec.len()); + + for command in command_vec { + let (command, args) = match command { + Value::String(str) => (str.to_owned(), Value::Table(IndexMap::new())), + Value::Table(kv) => { + let result = kv.get("command").ok_or_else({ + || { + Error::RequiredField( + "`args.commands.command` field for `runCommands`".into(), + ) + } + })?; + let command_name = match result { + Value::String(x) => x.to_owned(), + _ => { + return Err(Error::Constraint("`command` to be a string".into())) + .context_range(&args_pos)?; + } + }; + let result = kv.get("args").ok_or_else(|| { + Error::RequiredField("`args.commands.arg` field for `runCommands`".into()) + })?; + let args = match result { + x @ Value::Table(_) => x, + x @ Value::Array(_) => x, + _ => { + return Err(Error::Constraint("`args` to be a table or array".into()))?; + } + }; + (command_name, args.to_owned()) + } + _ => { + return constrain( + "`commands` to be an array that includes objects and strings only", + )?; + } + }; + command_result.push(Command { command, args }) + } + + return Ok(command_result); + } } -// impl Binding { -// pub fn new(input: BindingInput) -> ResultVec { -// if let Some(_) = input.id { -// return reserved("id"); -// } - -// serde_wasm_bindgen::Serializer::json_compatible(); -// if let Some(_) = input.foreach { -// return unexpected("`foreach` with unresolved variables"); -// } -// let (input, commands) = regularize_commands(input)?; - -// // TODO this is where we should validate that prefix has `finalKey == false` - -// // TODO: cleanup below now that we've updated types for `BindingInput` -// return Ok(Binding { -// commands: commands, -// key: input.key.into_inner().require("`key` field")?.unwrap(), -// when: input.when.into_inner().to_array(), -// mode: input.mode.into_inner().to_array(), -// priority: input -// .priority -// .map(|x| x.into_inner().resolve("`priority` field")) -// .unwrap_or_else(|| Ok(0))?, -// prefixes: input.prefixes.into_inner().to_array(), -// finalKey: input -// .finalKey -// .map(|x| x.into_inner().resolve("`finalKey` field")) -// .unwrap_or_else(|| Ok(true))?, -// repeat: input.repeat.map(|x| x.into_inner()), -// name: input.name.map(|x| x.into_inner()), -// description: input.description.map(|x| x.into_inner()), -// hideInPalette: input -// .hideInPalette -// .map(|x| x.into_inner().resolve("`hideInPalette` field")) -// .unwrap_or_else(|| Ok(false))?, -// hideInDocs: input -// .hideInDocs -// .map(|x| x.into_inner().resolve("`hideInDocs` field")) -// .unwrap_or_else(|| Ok(false))?, -// combinedName: input.combinedName.map(|x| x.into_inner()), -// combinedKey: input.combinedKey.map(|x| x.into_inner()), -// combinedDescription: input.combinedDescription.map(|x| x.into_inner()), -// kind: input.kind.clone().map(|x| x.into_inner()), -// }); -// } -// } +impl Binding { + pub fn new(input: BindingInput) -> ResultVec { + if let Some(_) = input.id { + return reserved("id")?; + } + + if let Some(_) = input.foreach { + return unexpected("`foreach` with unresolved variables")?; + } + let commands = regularize_commands(&input)?; + + // TODO this is where we should validate that prefix has `finalKey == false` + + // TODO: cleanup below now that we've updated types for `BindingInput` + return Ok(Binding { + commands: commands, + key: input.key.resolve("`key` field")?, + when: input.when.resolve("`when` field")?, + mode: input.mode.resolve("`mode` field")?, + priority: input.priority.resolve("`priority` field")?.unwrap_or(0.0), + prefixes: input.prefixes.resolve("`prefixes` fields")?, + finalKey: input.finalKey.resolve("`finalKey` field")?.unwrap_or(true), + repeat: input.repeat.resolve("`repeat` field")?, + name: input.name.resolve("`name` field")?, + description: input.description.resolve("`description` field")?, + hideInPalette: input + .hideInPalette + .resolve("`hideInPalette`")? + .unwrap_or(false), + hideInDocs: input + .hideInDocs + .resolve("`hideInPalette`")? + .unwrap_or(false), + combinedName: input.combinedName.resolve("`combinedName` field")?, + combinedKey: input.combinedKey.resolve("`combinedKey` field")?, + combinedDescription: input + .combinedDescription + .resolve("`combinedDescription` field")?, + kind: input.kind.resolve("`kind` field")?, + }); + } +} #[cfg(test)] mod tests { diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 0aed8d65..937c1d84 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,5 +1,5 @@ use crate::error::{Error, ErrorWithContext, ErrorsWithContext, Result, ResultVec}; -use crate::util::Merging; +use crate::util::{Merging, Resolving}; use crate::value::{EXPRESSION, Expanding, TypedValue, Value}; #[allow(unused_imports)] @@ -131,6 +131,13 @@ impl TryFrom for KeyBinding { } } +impl Resolving for KeyBinding { + fn resolve(self, name: impl Into) -> ResultVec { + self.require_constant()?; + Ok(self.into()) + } +} + impl Expanding for KeyBinding { fn is_constant(&self) -> bool { match self { diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index f11343f8..be5f5e67 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,4 +1,4 @@ -use crate::error::{Error, ErrorContext, ErrorWithContext, Result}; +use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, flatten_errors}; use indexmap::IndexMap; use log::info; @@ -9,13 +9,6 @@ pub trait Merging { fn merge(self, new: Self) -> Self; fn coalesce(self, new: Self) -> Self; } -pub trait Resolving { - fn resolve(self, name: impl Into) -> Result; -} - -pub trait Requiring { - fn require(self, name: impl Into) -> Result; -} // TODO: is there any way to avoid so much copying here impl Merging for toml::Table { @@ -111,17 +104,32 @@ impl Merging for bool { } } -impl Resolving> for Option { - fn resolve(self, _name: impl Into) -> Result { - return Ok(self); +pub trait Resolving { + fn resolve(self, name: impl Into) -> ResultVec; +} + +pub trait Requiring { + fn require(self, name: impl Into) -> Result; +} + +impl Resolving for Spanned +where + T: Resolving, +{ + fn resolve(self, name: impl Into) -> ResultVec { + let span = self.span(); + Ok(self.into_inner().resolve(name).context_range(&span)?) } } -impl Requiring for Option { - fn require(self, name: impl Into) -> Result { +impl Resolving> for Option +where + T: Resolving, +{ + fn resolve(self, name: impl Into) -> ResultVec> { match self { - Some(x) => Ok(x), - None => Err(Error::RequiredField(name.into()).into()), + Some(x) => Ok(Some(x.resolve(name)?)), + None => Ok(None), } } } @@ -149,27 +157,15 @@ where } } -impl Required> { - pub fn into_inner(self) -> Required { - return match self { - Required::DefaultValue => Required::DefaultValue, - Required::Value(val) => Required::Value(val.into_inner()), - }; - } -} - -impl Resolving for Required { - fn resolve(self, name: impl Into) -> Result { - return match self { - Required::DefaultValue => Err(Error::RequiredField(name.into()).into()), - Required::Value(val) => Ok(val), - }; - } -} - -impl Requiring for Required { - fn require(self, name: impl Into) -> Result { - return self.resolve(name.into()); +impl Resolving for Required +where + T: Resolving, +{ + fn resolve(self, name: impl Into) -> ResultVec { + match self { + Required::DefaultValue => Err(Error::RequiredField(name.into()))?, + Required::Value(x) => x.resolve(name), + } } } @@ -259,6 +255,20 @@ impl Plural { } } +impl Resolving> for Plural +where + T: Resolving + std::fmt::Debug, + U: std::fmt::Debug, +{ + fn resolve(self, name: impl Into) -> ResultVec> { + let vals = self.to_array(); + let name = name.into(); + Ok(flatten_errors( + vals.into_iter().map(|x| x.resolve(name.clone())), + )?) + } +} + impl Merging for Option { fn merge(self, new: Self) -> Self { return match new { diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs index 3951be1b..1e7793e8 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/value.rs @@ -278,6 +278,7 @@ where impl Expanding for TypedValue where T: From>, + T: TryFrom, { fn is_constant(&self) -> bool { match self { @@ -292,8 +293,12 @@ where return Ok(match self { TypedValue::Variable(v) => { let result = v.map_expressions(f)?; + info!("result {result:?} {}", result.is_constant()); if result.is_constant() { - TypedValue::Constant(TypedValue::Variable(result).into()) + // TODO: WIP debugging + let x = TypedValue::Constant(result.try_into()?); + info!("to constant: {x:?}"); + x } else { TypedValue::Variable(result) } @@ -307,10 +312,7 @@ impl From> for i64 { fn from(value: TypedValue) -> Self { return match value { TypedValue::Constant(x) => x, - TypedValue::Variable(value) => { - let toml: toml::Value = value.into(); - toml.try_into().expect("proper typing") - } + TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), }; } } @@ -319,10 +321,7 @@ impl From> for f64 { fn from(value: TypedValue) -> Self { return match value { TypedValue::Constant(x) => x, - TypedValue::Variable(value) => { - let toml: toml::Value = value.into(); - toml.try_into().expect("proper typing") - } + TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), }; } } @@ -331,10 +330,7 @@ impl From> for String { fn from(value: TypedValue) -> Self { return match value { TypedValue::Constant(x) => x, - TypedValue::Variable(value) => { - let toml: toml::Value = value.into(); - toml.try_into().expect("proper typing") - } + TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), }; } } @@ -343,14 +339,32 @@ impl From> for bool { fn from(value: TypedValue) -> Self { return match value { TypedValue::Constant(x) => x, - TypedValue::Variable(value) => { - let toml: toml::Value = value.into(); - toml.try_into().expect("proper typing") - } + TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), }; } } +impl Resolving for TypedValue +where + T: Serialize + std::fmt::Debug, + TypedValue: Expanding + Clone + Into, +{ + fn resolve(self, name: impl Into) -> ResultVec { + self.require_constant() + .context_str(format!("for {}", name.into()))?; + return Ok(self.into()); + } +} + +impl Resolving> for TypedValue +where + T: Serialize + std::fmt::Debug, +{ + fn resolve(self, _name: impl Into) -> ResultVec> { + return Ok(self); + } +} + impl Merging for TypedValue { fn coalesce(self, new: Self) -> Self { return new; From 3e7caa323bef4e629dacd8dd0437e6e07aacfe8a Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 2 Sep 2025 00:02:50 -0400 Subject: [PATCH 37/79] compiled `define` processing Created using spr 1.3.6-beta.1 --- notes.md | 37 +-- src/rust/parsing/src/bind.rs | 19 +- src/rust/parsing/src/define.rs | 419 ++++++++++++++------------------- src/rust/parsing/src/error.rs | 2 - src/rust/parsing/src/util.rs | 6 + src/rust/parsing/src/value.rs | 29 ++- 6 files changed, 237 insertions(+), 275 deletions(-) diff --git a/notes.md b/notes.md index 880f6cf4..f60a7335 100644 --- a/notes.md +++ b/notes.md @@ -89,30 +89,31 @@ Integration test debugging: - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - [ ] expansion of `[define]` sections - - [ ] implement support for resolving `var.`, `command.` and `bind.` definitions - - [ ] problem: spannd doesn't work with flatten; we can solve this by + - [X] implement support for resolving `var.`, `command.` and `bind.` definitions + - [X] problem: spannd doesn't work with flatten; we can solve this by creating an `id` field for `command` and `bind` that will throw an error if populatd when passed on to the non-input constructors - - [ ] setup default keyword for `bind` - - [ ] rework how `var.` works, resolving it at run time, not definition time + - [X] setup default keyword for `bind` + - [X] rework how `var.` works, resolving it at run time, not definition time + - [X] implement `default` expansion for `bind` + - [X] make sure to error on fields that cannot have runtime computation + (only certain fields can be evaluated at runtime: `args` and `repeat`) + - [X] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - [ ] unit tests for `define` parsing - [ ] rework `Required` so we get a meaningful error message when the keybinding is wrong + NOTE: is this still an issue (write a test for it) - [ ] tests for `var` - - [ ] get evaluation of computed elements working - - [ ] use rhai to implement expression evaluation - - [ ] preparse all `{{}}` into - - [ ] parse time variables (for loop, `bind.` and `command.`) - - [ ] interpolated string - - [ ] single variables references (no `rhai` required) - - [ ] actual expressions that are parsed into an AST by `rhai` - - [ ] disable keywords/features that are for multiline or assignment - - [ ] include tests to prevent use of `command.` and `bind.` variables - - [ ] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - - [ ] implement `default` expansion for `bind` - - [ ] make sure to error on fields that cannot have runtime computation - (only certain fields can be evaluated at runtime: `args` and `repeat`) - - [ ] implement support for tags on `bind` (for filter them) + - [ ] get evaluation of computed elements working `Command` and `Bind` working + - [ ] use rhai to implement expression evaluation + - [ ] preparse all `{{}}` into + - [ ] evaluate expressions + - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls + - [ ] implementation + - [ ] unit tests + - [ ] try it out from extension debugging + - [ ] write an integration test + - [ ] implement support for tags on `bind` (for filter them) - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] foreach expansion within a KeyFile context diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index a86a3d94..0723f148 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -19,7 +19,7 @@ use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; mod foreach; -mod validation; +pub mod validation; use crate::bind::foreach::expand_keys; use crate::bind::validation::{BindingReference, KeyBinding}; @@ -360,6 +360,15 @@ impl CommandInput { } } +impl From for Value { + fn from(value: Command) -> Self { + return Value::Table(IndexMap::from([ + ("command".to_string(), Value::String(value.command)), + ("args".to_string(), value.args), + ])); + } +} + #[wasm_bindgen(getter_with_clone)] #[derive(Clone, Debug, Serialize)] pub struct Command { @@ -481,6 +490,13 @@ fn expand_foreach_values(foreach: IndexMap>) -> Vec Option { + if let Some(x) = self.default { + Some(x.into_inner().0) + } else { + None + } + } fn is_constant(&self) -> bool { [ self.command.is_constant(), @@ -702,7 +718,6 @@ impl Binding { // TODO this is where we should validate that prefix has `finalKey == false` - // TODO: cleanup below now that we've updated types for `BindingInput` return Ok(Binding { commands: commands, key: input.key.resolve("`key` field")?, diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index b7f8e5d6..c0476355 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,252 +1,177 @@ // TODO: refactor this *AFTER* we've got `bind` working again -// use core::error; -// use std::collections::HashMap; - -// use crate::bind::{Binding, BindingInput, Command, CommandInput}; -// use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; -// use crate::util::Requiring; -// use crate::value::VariableExpanding; - -// use indexmap::IndexMap; -// #[allow(unused_imports)] -// use log::info; -// use serde::{Deserialize, Serialize}; -// use serde_wasm_bindgen; -// use toml::Spanned; -// use wasm_bindgen::prelude::*; - -// #[derive(Deserialize, Serialize, Clone, Debug)] -// pub struct DefineInput { -// pub var: Option>>>, -// pub command: Option>>, -// pub bind: Option>>, -// } - -// pub trait VariableResolver { -// fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()>; -// } - -// #[wasm_bindgen] -// #[derive(Clone, Debug, Default)] -// pub struct Define { -// #[wasm_bindgen(skip)] -// pub bind: HashMap, -// #[wasm_bindgen(skip)] -// pub command: HashMap, -// #[wasm_bindgen(skip)] -// pub var: HashMap, -// } - -// fn map_with_err(x: HashMap>, f: f) -> ResultVec> -// where -// F: FnMut(T) -> Result, -// { -// let mut errors = Vec::new(); -// let result = x -// .into_iter() -// .filter_map(|(k, v)| { -// let span = v.span(); -// let result = f(v.into_inner()).context_range(&span); -// return result.map_err(|e| errors.push(e)).ok().map(|v| (k, v)); -// }) -// .collect(); -// if errors.len() > 0 { -// return Err(errors); -// } else { -// return Ok(result); -// } -// } - -// impl Define { -// pub fn new(input: DefineInput) -> ResultVec { -// // STEP 1: resolve all definitions so that there are no interpolations of -// // `var.`, `bind.` or `command.` variables -// let mut resolved_bind = HashMap::>::new(); -// let mut resolved_command = HashMap::>::new(); -// let mut resolved_var = HashMap::::new(); -// let mut errors = Vec::new(); - -// // STEP 1a: resolve [[define.var]] blocks; fields can have any structure but they -// // must only reference previously defined variables (we've included the TOML feature -// // to preserve order, so variables can reference other variables defined within the -// // same block) - -// // TODO: do not resolve `var` values, and do not allow `{{}}` inside of `var.` values -// for def_block in input.var.into_iter().flatten() { -// for (var, mut value) in def_block.into_iter() { -// let mut var_result = value.expand_with_getter(|id| { -// if let Some((prefix, name)) = id.split_once('.') { -// if prefix == "var" { -// return Err(Error::Constraint( -// "no references to `var` within a `var` definition".into() -// ))?; -// } else if prefix == "bind" || prefix == "command" { -// return Err(Error::ForwardReference(format!( -// "`{id}`; you cannot refer to `{prefix}` values within `var` definitions" -// )))?; -// } -// } -// // TODO: refactor so that we use a unique enum type instead of -// // Some/None to signal resolution - -// // other types of variables are left unresolved -// return Ok(None); -// }); -// if let Err(ref mut errs) = var_result { -// errors.append(errs); -// } -// resolved_var.insert(var.clone(), value.get_ref().clone()); -// } -// } - -// // STEP 1b: resolve [[define.command]] blocks -// for mut def in input.command.into_iter().flatten() { -// let mut command_result = def.get_mut().expand_with_getter(|id| { -// if let Some((prefix, name)) = id.split_once('.') { -// if prefix == "var" { -// let value = resolved_var -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; -// return Ok(Some(value.clone())); -// } else if prefix == "command" { -// let val = resolved_command.get(id).ok_or_else(|| { -// Error::UndefinedVariable(format!("`{id}`")) -// })?; -// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)) -// } else if prefix == "bind" { -// return Err(Error::ForwardReference(format!( -// "`{id}`; you cannot refer to `{prefix}` values within `command` definitions" -// )))?; -// } -// } -// return Ok(None); -// }); -// if let Err(ref mut errs) = command_result { -// errors.append(errs); -// } - -// let id = def.get_ref().id.clone(); -// resolved_command.insert( -// id.require("id") -// .context_range(&def.span())? -// .get_ref() -// .clone(), -// def, -// ); -// } - -// // STEP 1c: resolve [[define.bind]] blocks -// for mut def in input.bind.into_iter().flatten() { -// let mut bind_result = def.get_mut().expand_with_getter(|id| { -// if let Some((prefix, name)) = id.split_once('.') { -// if prefix == "var" { -// let value = resolved_var -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; -// return Ok(Some(value.clone())); -// } else if prefix == "command" { -// let val = resolved_command -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; -// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); -// } else if prefix == "bind" { -// let val = resolved_bind -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(format!("`{id}`")))?; -// return Ok(Some(toml::Value::try_from(val.get_ref().without_id())?)); -// } -// } -// return Ok(None); -// }); -// if let Err(ref mut errs) = bind_result { -// errors.append(errs); -// } - -// let id = def.get_ref().id.clone(); -// resolved_bind.insert( -// id.require("id") -// .context_range(&def.span())? -// .get_ref() -// .clone(), -// def, -// ); -// } - -// // STEP 2: cleanup results for use in `Define` struct - -// if errors.len() > 0 { -// return Err(errors); -// } else { -// // TODO: because resolution to the Binding and Command structs does not occur until -// // later, we could, in theory end up with a *lot* of errors for the same lines, it -// // will be important to clean up the output to only show one of these errors and -// // remove the other instances; or convince our selves no such issue will arise -// let bind = resolved_bind -// .into_iter() -// .map(|(k, v)| (k, v.into_inner().without_id())) -// .collect(); -// let command = map_with_err(resolved_command, |c| Command::new(c.without_id()))?; -// return Ok(Define { -// bind, -// command, -// var: resolved_var, -// }); -// } -// } -// } - -// // NOTE: why don't we provide public access to `bind` and `command`: this avoids -// // extra implementation work, when the main use case for these two categories of -// // definitions is to make the binding file more concise; `var.` values on -// // the other hand are often used at runtime -// #[wasm_bindgen] -// impl Define { -// pub fn var(&self, key: &str) -> Result { -// let to_json = serde_wasm_bindgen::Serializer::json_compatible(); -// let value = self.var.get(key).require(format!("`{key}` field"))?; -// return match value.serialize(&to_json) { -// Ok(result) => Ok(result), -// Err(_) => unexpected("unexpected serialization error"), -// }; -// } -// } - -// // TODO: we don't actually want to resolve `var.`s as they might change during runtime -// // TODO: we need to avoid parsing expressions as variables to insert - -// impl VariableResolver for Define { -// fn resolve_variables(&self, x: &mut impl VariableExpanding) -> ResultVec<()> { -// x.expand_with_getter(|var| { -// if let Some((prefix, name)) = var.split_once('.') { -// if prefix == "var" { -// return Ok(Some( -// self.var -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(var.into()))? -// .clone(), -// )); -// } else if prefix == "command" { -// let val = self -// .command -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(var.into()))? -// .clone(); -// return Ok(Some(toml::Value::try_from(val)?)); -// } else if prefix == "bind" { -// let val = self -// .bind -// .get(name) -// .ok_or_else(|| Error::UndefinedVariable(var.into()))? -// .clone(); -// return Ok(Some(toml::Value::try_from(val)?)); -// } -// } -// return Ok(None); -// })?; -// return Ok(()); -// } -// } +use core::error; +use std::collections::{HashMap, hash_map}; + +use crate::bind::validation::BindingReference; +use crate::bind::{Binding, BindingInput, Command, CommandInput}; +use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; +use crate::util::{Merging, Resolving}; +use crate::value::{Expander, Expanding, Value}; + +use indexmap::IndexMap; +use lazy_static::lazy_static; +#[allow(unused_imports)] +use log::info; +use regex::Regex; +use serde::{Deserialize, Serialize}; +use serde_wasm_bindgen; +use toml::Spanned; +use wasm_bindgen::prelude::*; + +#[derive(Deserialize, Clone, Debug)] +pub struct DefineInput { + pub var: Option>>>, + pub command: Option>>, + pub bind: Option>>, +} + +#[wasm_bindgen] +#[derive(Clone, Debug, Default)] +pub struct Define { + #[wasm_bindgen(skip)] + pub bind: HashMap, + #[wasm_bindgen(skip)] + pub command: HashMap, + #[wasm_bindgen(skip)] + pub var: HashMap, +} + +impl Define { + pub fn new(input: DefineInput) -> ResultVec { + let mut resolved_bind = HashMap::::new(); + let mut resolved_command = HashMap::::new(); + let mut resolved_var = HashMap::::new(); + let mut errors: Vec = Vec::new(); + + for def_block in input.var.into_iter().flatten() { + for (var, value) in def_block.into_iter() { + match value.resolve("`{var}` definition") { + Ok(x) => { + resolved_var.insert(var, x); + } + Err(mut e) => { + errors.append(&mut e.errors); + } + } + } + } + + for def in input.command.into_iter().flatten() { + let id = def.get_ref().id.clone(); + let span = id + .ok_or_else(|| Error::RequiredField("`id` field".into())) + .context_range(&def.span()); + match span { + Err(e) => errors.push(e.into()), + Ok(x) => match x.resolve("`id` field") { + Err(mut e) => { + errors.append(&mut e.errors); + } + Ok(id) => { + resolved_command.insert(id, def.into_inner()); + } + }, + } + } + + for def in input.bind.into_iter().flatten() { + let id = def.get_ref().id.clone(); + let span = id + .ok_or_else(|| Error::RequiredField("`id` field".into())) + .context_range(&def.span()); + match span { + Err(e) => errors.push(e.into()), + Ok(x) => match x.resolve("`id` field") { + Err(mut e) => { + errors.append(&mut e.errors); + } + Ok(x) => { + resolved_bind.insert(x, def.into_inner()); + } + }, + } + } + + if errors.len() > 0 { + return Err(errors.into()); + } else { + // TODO: because resolution to the Binding and Command structs does not occur until + // later, we could, in theory end up with a *lot* of errors for the same lines, it + // will be important to clean up the output to only show one of these errors and + // remove the other instances; or convince our selves no such issue will arise + return Ok(Define { + bind: resolved_bind, + command: resolved_command, + var: resolved_var, + }); + } + } +} + +// NOTE: why don't we provide public access to `bind` and `command`: this avoids +// extra implementation work, when the main use case for these two categories of +// definitions is to make the binding file more concise; `var.` values on +// the other hand are often used at runtime +#[wasm_bindgen] +impl Define { + // TODO: implement rhai evaluation + pub fn var(&self, key: &str) -> Result { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let value = self + .var + .get(key) + .ok_or_else(|| Error::RequiredField(format!("`{key}` field")))?; + return match value.serialize(&to_json) { + Ok(result) => Ok(result), + Err(_) => unexpected("unexpected serialization error"), + }; + } +} + +lazy_static! { + pub static ref BIND_REF: Regex = Regex::new(r"^bind\.([\w--\d]+\w*)$").unwrap(); + pub static ref COMMAND_REF: Regex = Regex::new(r"^command\.([\w--\d]+\w*)$").unwrap(); +} + +impl Define { + fn expand(&mut self, binding: BindingInput) -> ResultVec { + // resolve default values + let binding = if let Some(ref default) = binding.default { + let BindingReference(name) = default.as_ref(); + let entry = self.bind.entry(name.clone()); + let occupied_entry = match entry { + hash_map::Entry::Vacant(_) => Err(Error::UndefinedVariable(name.clone()))?, + hash_map::Entry::Occupied(entry) => entry, + }; + let mut default_value; + if !occupied_entry.get().is_constant() { + default_value = occupied_entry.remove(); + default_value = self.expand(default_value)?; + self.bind.insert(name.clone(), default_value.clone()); + } else { + default_value = occupied_entry.get().clone() + } + default_value.merge(binding) + } else { + binding + }; + + return binding.map_expressions(&|exp: String| { + let command = COMMAND_REF.captures(&exp); + if let Some(captures) = command { + let name = captures.get(1).expect("variable name").as_str(); + return Ok(self.command[name].without_id().into()); + } + if BIND_REF.is_match(&exp) { + Err(Error::Constraint( + "`bind.` reference in `default` field only".into(), + ))? + } + return Ok(Value::Expression(exp)); + }); + } +} // mod tests { // // use test_log::test; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 9afd9989..9b2c83fe 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -30,8 +30,6 @@ pub enum Error { Unresolved(String), #[error("undefined variable {0}")] UndefinedVariable(String), - #[error("forward reference to {0}")] - ForwardReference(String), #[error("reserved field name {0}")] ReservedField(&'static str), #[error("parsing regex failed with {0}")] diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index be5f5e67..edc0bd3c 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -205,6 +205,12 @@ impl Required { } } +impl Resolving for String { + fn resolve(self, name: impl Into) -> ResultVec { + return Ok(self); + } +} + // TODO: use `try_from` to improve error messages #[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged)] diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs index 1e7793e8..9062b817 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/value.rs @@ -144,6 +144,12 @@ impl Merging for Value { } } +pub trait Expander { + fn expand(self, x: T) -> ResultVec + where + T: Expanding + Merging; +} + pub trait Expanding { fn map_expressions(self, f: &F) -> ResultVec where @@ -244,6 +250,19 @@ impl From for toml::Value { } } +impl Resolving for Value { + fn resolve(self, _name: impl Into) -> ResultVec { + Ok(self) + } +} + +impl Resolving for Value { + fn resolve(self, name: impl Into) -> ResultVec { + self.require_constant().context_str(name)?; + return Ok(self.into()); + } +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] #[serde(try_from = "toml::Value")] pub enum TypedValue @@ -275,10 +294,9 @@ where } } -impl Expanding for TypedValue +impl<'de, T> Expanding for TypedValue where - T: From>, - T: TryFrom, + T: std::fmt::Debug + Deserialize<'de> + Serialize, { fn is_constant(&self) -> bool { match self { @@ -293,11 +311,10 @@ where return Ok(match self { TypedValue::Variable(v) => { let result = v.map_expressions(f)?; - info!("result {result:?} {}", result.is_constant()); if result.is_constant() { // TODO: WIP debugging - let x = TypedValue::Constant(result.try_into()?); - info!("to constant: {x:?}"); + let toml: toml::Value = result.into(); + let x = TypedValue::Constant(toml.try_into()?); x } else { TypedValue::Variable(result) From 22e4182118bc71d19a4474da332fbc451eaee348 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 2 Sep 2025 10:59:30 -0400 Subject: [PATCH 38/79] first define test passing Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 54 ++--- src/rust/parsing/src/bind.rs | 22 +- src/rust/parsing/src/define.rs | 376 ++++++++++++++++----------------- src/rust/parsing/src/value.rs | 23 +- 4 files changed, 243 insertions(+), 232 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 0ab579d0..c159ab2d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#162fd0", + "statusBarItem.warningBackground": "#f41a49", "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#162fd0", + "statusBarItem.warningHoverBackground": "#f41a49", "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#233cdd", + "statusBarItem.remoteBackground": "#ff2756", "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#3049ea", + "statusBarItem.remoteHoverBackground": "#ff3463", "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#162fd0", + "statusBar.background": "#f41a49", "statusBar.foreground": "#ffffff", - "statusBar.border": "#162fd0", - "statusBar.debuggingBackground": "#162fd0", + "statusBar.border": "#f41a49", + "statusBar.debuggingBackground": "#f41a49", "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#162fd0", - "statusBar.noFolderBackground": "#162fd0", + "statusBar.debuggingBorder": "#f41a49", + "statusBar.noFolderBackground": "#f41a49", "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#162fd0", - "statusBar.prominentBackground": "#162fd0", + "statusBar.noFolderBorder": "#f41a49", + "statusBar.prominentBackground": "#f41a49", "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#162fd0", + "statusBar.prominentHoverBackground": "#f41a49", "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#162fd099", - "progressBar.background": "#162fd0", - "textLink.foreground": "#566fff", - "textLink.activeForeground": "#637cff", - "selection.background": "#0922c3", - "list.highlightForeground": "#162fd0", - "list.focusAndSelectionOutline": "#162fd099", - "button.background": "#162fd0", + "focusBorder": "#f41a4999", + "progressBar.background": "#f41a49", + "textLink.foreground": "#ff5a89", + "textLink.activeForeground": "#ff6796", + "selection.background": "#e70d3c", + "list.highlightForeground": "#f41a49", + "list.focusAndSelectionOutline": "#f41a4999", + "button.background": "#f41a49", "button.foreground": "#ffffff", - "button.hoverBackground": "#233cdd", - "tab.activeBorderTop": "#233cdd", - "pickerGroup.foreground": "#233cdd", - "list.activeSelectionBackground": "#162fd04d", - "panelTitle.activeBorder": "#233cdd", - "activityBar.activeBorder": "#162fd0", + "button.hoverBackground": "#ff2756", + "tab.activeBorderTop": "#ff2756", + "pickerGroup.foreground": "#ff2756", + "list.activeSelectionBackground": "#f41a494d", + "panelTitle.activeBorder": "#ff2756", + "activityBar.activeBorder": "#f41a49", "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#162fd0" + "activityBarBadge.background": "#f41a49" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 0723f148..eb228c22 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -361,11 +361,16 @@ impl CommandInput { } impl From for Value { - fn from(value: Command) -> Self { - return Value::Table(IndexMap::from([ - ("command".to_string(), Value::String(value.command)), - ("args".to_string(), value.args), - ])); + fn from(value: CommandInput) -> Self { + let mut entries = IndexMap::new(); + let command = value.command.into_inner(); + if let Required::Value(command_value) = command { + entries.insert("command".to_string(), command_value.into()); + } + if let Some(arg_value) = value.args { + entries.insert("args".to_string(), arg_value.into_inner()); + } + return Value::Table(entries); } } @@ -490,13 +495,6 @@ fn expand_foreach_values(foreach: IndexMap>) -> Vec Option { - if let Some(x) = self.default { - Some(x.into_inner().0) - } else { - None - } - } fn is_constant(&self) -> bool { [ self.command.is_constant(), diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index c0476355..18da4ed1 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -173,194 +173,188 @@ impl Define { } } -// mod tests { -// // use test_log::test; - -// use super::*; -// #[test] -// fn simple_parsing() { -// let data = r#" -// [[var]] -// y = "bill" - -// [[bind]] -// id = "foo" -// key = "x" -// command = "foo" -// args = { k = 1, h = 2 } - -// [[command]] -// id = "foobar" -// command = "runCommands" -// args.commands = ["foo", "bar"] - -// [[var]] -// joe = "bob" - -// "#; - -// let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - -// assert_eq!(result.var.get("y").unwrap().as_str().unwrap(), "bill"); -// assert_eq!(result.var.get("joe").unwrap().as_str().unwrap(), "bob"); -// let foo = result.bind.get("foo").unwrap(); -// assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); -// assert_eq!( -// foo.args -// .as_ref() -// .unwrap() -// .get_ref() -// .get("k") -// .unwrap() -// .as_integer() -// .unwrap(), -// 1 -// ); - -// assert_eq!( -// foo.args -// .as_ref() -// .unwrap() -// .get_ref() -// .get("h") -// .unwrap() -// .as_integer() -// .unwrap(), -// 2 -// ); - -// let foobar = result.command.get("foobar").unwrap(); -// assert_eq!(foobar.command, "runCommands"); -// let commands = foobar.args.get("commands").unwrap().as_array().unwrap(); -// assert_eq!(commands[0].as_str().unwrap(), "foo"); -// assert_eq!(commands[1].as_str().unwrap(), "bar"); -// } - -// #[test] -// fn parsing_resolved_variables() { -// let data = r#" -// [[var]] -// foo = 1 - -// [[var]] -// foo_string = "number-{{var.foo}}" - -// [[command]] -// id = "run_shebang" -// command = "shebang" -// args.a = 1 -// args.b = "{{var.foo_string}}" - -// [[bind]] -// id = "whole_shebang" -// key = "a" -// name = "the whole shebang" -// command = "runCommands" -// args.commands = ["{{command.run_shebang}}", "bar"] -// "#; - -// let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); -// let bind_args = result -// .bind -// .get("whole_shebang") -// .as_ref() -// .unwrap() -// .args -// .as_ref() -// .unwrap(); -// let bind_commands = bind_args -// .get_ref() -// .get("commands") -// .unwrap() -// .as_array() -// .unwrap(); -// assert_eq!( -// bind_commands[0].get("command").unwrap().as_str().unwrap(), -// "shebang" -// ); -// assert_eq!( -// bind_commands[0] -// .get("args") -// .unwrap() -// .get("b") -// .unwrap() -// .as_str() -// .unwrap(), -// "number-1" -// ); -// assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); -// } - -// #[test] -// fn parsing_order_error() { -// let data = r#" -// [[var]] -// k = "{{command.foo}}" - -// [[var]] -// a = 1 - -// [[var]] -// b = "{{var.a}}-boot" - -// [[command]] -// id = "foo" -// command = "joe" -// args.x = 1 - -// [[command]] -// id = "bar" -// command = "runCommands" -// args.commands = ["{{command.biz}}", "baz"] - -// [[command]] -// id = "biz" -// command = "bob" -// args.y = 2 -// args.x = "{{bind.horace}}" - -// [[bind]] -// id = "horace" -// key = "ctrl+k" -// command = "cursorLeft" -// args.value = "{{count}}" - -// [[bind]] -// default = "{{bind.horace}}" -// id = "bob" -// key = "ctrl+y" -// command = "cursorRight" - -// [[bind]] -// default = "{{bind.will}}" -// id = "bob" -// key = "ctrl+k" -// command = "cursorDown" -// "#; -// // TODO: add `default` key to `bind` so we can accomplish the todo below -// // TODO: test for missing `bind` -// let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); -// assert!(if let Error::ForwardReference(ref str) = result[0].error { -// str.starts_with("`command.foo`") -// } else { -// false -// }); -// assert!(if let Error::Constraint(ref str) = result[1].error { -// str.starts_with("no references to `var`") -// } else { -// false -// }); -// assert!(if let Error::UndefinedVariable(ref str) = result[2].error { -// str.starts_with("`command.biz`") -// } else { -// false -// }); -// assert!(if let Error::ForwardReference(ref str) = result[3].error { -// str.starts_with("`bind.horace`") -// } else { -// false -// }); -// info!("result: {:#?}", result); -// assert_eq!(result.len(), 4); -// } -// } +mod tests { + // use test_log::test; + + use super::*; + #[test] + fn simple_parsing() { + let data = r#" + [[var]] + y = "bill" + + [[bind]] + id = "foo" + key = "x" + command = "foo" + args = { k = 1, h = 2 } + + [[command]] + id = "foobar" + command = "runCommands" + args.commands = ["foo", "bar"] + + [[var]] + joe = "bob" + + "#; + + let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); + + assert_eq!(result.var.get("y").unwrap(), &Value::String("bill".into())); + assert_eq!(result.var.get("joe").unwrap(), &Value::String("bob".into())); + let foo = result.bind.get("foo").unwrap(); + assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); + let args = foo.args.as_ref().unwrap().clone().into_inner(); + assert_eq!( + args, + Value::Table(IndexMap::from([ + ("k".into(), Value::Integer(1)), + ("h".into(), Value::Integer(2)) + ])) + ); + + let foobar = result.command.get("foobar").unwrap(); + let command: String = foobar.command.clone().resolve("`command`").unwrap(); + assert_eq!(command, "runCommands"); + let commands = foobar.args.as_ref().unwrap().clone().into_inner(); + assert_eq!( + commands, + Value::Table(IndexMap::from([( + "commands".into(), + Value::Array(vec![ + Value::String("foo".into()), + Value::String("bar".into()) + ]) + )])) + ); + } + + // #[test] + // fn parsing_resolved_variables() { + // let data = r#" + // [[var]] + // foo = 1 + + // [[var]] + // foo_string = "number-{{var.foo}}" + + // [[command]] + // id = "run_shebang" + // command = "shebang" + // args.a = 1 + // args.b = "{{var.foo_string}}" + + // [[bind]] + // id = "whole_shebang" + // key = "a" + // name = "the whole shebang" + // command = "runCommands" + // args.commands = ["{{command.run_shebang}}", "bar"] + // "#; + + // let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); + // let bind_args = result + // .bind + // .get("whole_shebang") + // .as_ref() + // .unwrap() + // .args + // .as_ref() + // .unwrap(); + // let bind_commands = bind_args + // .get_ref() + // .get("commands") + // .unwrap() + // .as_array() + // .unwrap(); + // assert_eq!( + // bind_commands[0].get("command").unwrap().as_str().unwrap(), + // "shebang" + // ); + // assert_eq!( + // bind_commands[0] + // .get("args") + // .unwrap() + // .get("b") + // .unwrap() + // .as_str() + // .unwrap(), + // "number-1" + // ); + // assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); + // } + + // #[test] + // fn parsing_order_error() { + // let data = r#" + // [[var]] + // k = "{{command.foo}}" + + // [[var]] + // a = 1 + + // [[var]] + // b = "{{var.a}}-boot" + + // [[command]] + // id = "foo" + // command = "joe" + // args.x = 1 + + // [[command]] + // id = "bar" + // command = "runCommands" + // args.commands = ["{{command.biz}}", "baz"] + + // [[command]] + // id = "biz" + // command = "bob" + // args.y = 2 + // args.x = "{{bind.horace}}" + + // [[bind]] + // id = "horace" + // key = "ctrl+k" + // command = "cursorLeft" + // args.value = "{{count}}" + + // [[bind]] + // default = "{{bind.horace}}" + // id = "bob" + // key = "ctrl+y" + // command = "cursorRight" + + // [[bind]] + // default = "{{bind.will}}" + // id = "bob" + // key = "ctrl+k" + // command = "cursorDown" + // "#; + // // TODO: add `default` key to `bind` so we can accomplish the todo below + // // TODO: test for missing `bind` + // let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); + // assert!(if let Error::ForwardReference(ref str) = result[0].error { + // str.starts_with("`command.foo`") + // } else { + // false + // }); + // assert!(if let Error::Constraint(ref str) = result[1].error { + // str.starts_with("no references to `var`") + // } else { + // false + // }); + // assert!(if let Error::UndefinedVariable(ref str) = result[2].error { + // str.starts_with("`command.biz`") + // } else { + // false + // }); + // assert!(if let Error::ForwardReference(ref str) = result[3].error { + // str.starts_with("`bind.horace`") + // } else { + // false + // }); + // info!("result: {:#?}", result); + // assert_eq!(result.len(), 4); + // } +} diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs index 9062b817..af81919a 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/value.rs @@ -325,8 +325,8 @@ where } } -impl From> for i64 { - fn from(value: TypedValue) -> Self { +impl From> for i32 { + fn from(value: TypedValue) -> Self { return match value { TypedValue::Constant(x) => x, TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), @@ -361,6 +361,25 @@ impl From> for bool { } } +impl From> for Value +where + T: Into + Serialize + std::fmt::Debug, +{ + fn from(value: TypedValue) -> Self { + return match value { + TypedValue::Constant(x) => { + let toml: toml::Value = x.into(); + // the reasons for failing this `try_into` should not be true of the types + // we can use TypedValue with. (We only want to be able to use + // TypedValues for objects that can round trip serialize): this is any value + // that can't be stored directly in JSON (e.g. a large 64-bit number). + toml.try_into().expect("serializable value") + } + TypedValue::Variable(x) => x, + }; + } +} + impl Resolving for TypedValue where T: Serialize + std::fmt::Debug, From 270d00b9edb37a36ae62b73fd90853ecea030d6d Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 2 Sep 2025 22:52:49 -0400 Subject: [PATCH 39/79] working basic parsing for keyFile Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 54 +++---- notes.md | 10 +- src/rust/parsing/src/bind.rs | 4 +- src/rust/parsing/src/define.rs | 132 +---------------- src/rust/parsing/src/file.rs | 252 +++++++++++++++++---------------- 5 files changed, 163 insertions(+), 289 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c159ab2d..5db09442 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#f41a49", + "statusBarItem.warningBackground": "#e35b35", "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#f41a49", + "statusBarItem.warningHoverBackground": "#e35b35", "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#ff2756", + "statusBarItem.remoteBackground": "#f06842", "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#ff3463", + "statusBarItem.remoteHoverBackground": "#fd754f", "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#f41a49", + "statusBar.background": "#e35b35", "statusBar.foreground": "#ffffff", - "statusBar.border": "#f41a49", - "statusBar.debuggingBackground": "#f41a49", + "statusBar.border": "#e35b35", + "statusBar.debuggingBackground": "#e35b35", "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#f41a49", - "statusBar.noFolderBackground": "#f41a49", + "statusBar.debuggingBorder": "#e35b35", + "statusBar.noFolderBackground": "#e35b35", "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#f41a49", - "statusBar.prominentBackground": "#f41a49", + "statusBar.noFolderBorder": "#e35b35", + "statusBar.prominentBackground": "#e35b35", "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#f41a49", + "statusBar.prominentHoverBackground": "#e35b35", "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#f41a4999", - "progressBar.background": "#f41a49", - "textLink.foreground": "#ff5a89", - "textLink.activeForeground": "#ff6796", - "selection.background": "#e70d3c", - "list.highlightForeground": "#f41a49", - "list.focusAndSelectionOutline": "#f41a4999", - "button.background": "#f41a49", + "focusBorder": "#e35b3599", + "progressBar.background": "#e35b35", + "textLink.foreground": "#ff9b75", + "textLink.activeForeground": "#ffa882", + "selection.background": "#d64e28", + "list.highlightForeground": "#e35b35", + "list.focusAndSelectionOutline": "#e35b3599", + "button.background": "#e35b35", "button.foreground": "#ffffff", - "button.hoverBackground": "#ff2756", - "tab.activeBorderTop": "#ff2756", - "pickerGroup.foreground": "#ff2756", - "list.activeSelectionBackground": "#f41a494d", - "panelTitle.activeBorder": "#ff2756", - "activityBar.activeBorder": "#f41a49", + "button.hoverBackground": "#f06842", + "tab.activeBorderTop": "#f06842", + "pickerGroup.foreground": "#f06842", + "list.activeSelectionBackground": "#e35b354d", + "panelTitle.activeBorder": "#f06842", + "activityBar.activeBorder": "#e35b35", "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#f41a49" + "activityBarBadge.background": "#e35b35" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/notes.md b/notes.md index f60a7335..4c1208b6 100644 --- a/notes.md +++ b/notes.md @@ -88,7 +88,7 @@ Integration test debugging: - [X] we need to process errors to generate the diagnostic outputs - [X] properly identify spans: both `[[bind]]` header and entire `[[bind]]` region NOTE: short term goal here is to support literate docs - - [ ] expansion of `[define]` sections + - [X] expansion of `[define]` sections - [X] implement support for resolving `var.`, `command.` and `bind.` definitions - [X] problem: spannd doesn't work with flatten; we can solve this by creating an `id` field for `command` and `bind` that will throw @@ -99,11 +99,6 @@ Integration test debugging: - [X] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - [X] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - - [ ] unit tests for `define` parsing - - [ ] rework `Required` so we get a meaningful error message - when the keybinding is wrong - NOTE: is this still an issue (write a test for it) - - [ ] tests for `var` - [ ] get evaluation of computed elements working `Command` and `Bind` working - [ ] use rhai to implement expression evaluation - [ ] preparse all `{{}}` into @@ -111,9 +106,10 @@ Integration test debugging: - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls - [ ] implementation - [ ] unit tests + - [X] basic parsing + - [ ] define expansion for `bind.` and `command.` - [ ] try it out from extension debugging - [ ] write an integration test - - [ ] implement support for tags on `bind` (for filter them) - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] foreach expansion within a KeyFile context diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index eb228c22..e6255e9e 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -181,7 +181,7 @@ pub struct BindingInput { * - `command` will be repeated the given * number of times. */ - repeat: Option>>, + repeat: Option>>, /** * @forBindingField bind @@ -421,7 +421,7 @@ pub struct Binding { pub priority: f64, pub prefixes: Vec, pub finalKey: bool, - pub(crate) repeat: Option>, + pub(crate) repeat: Option>, pub name: Option, pub description: Option, pub hideInPalette: bool, diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 18da4ed1..42c246df 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -19,7 +19,7 @@ use serde_wasm_bindgen; use toml::Spanned; use wasm_bindgen::prelude::*; -#[derive(Deserialize, Clone, Debug)] +#[derive(Deserialize, Clone, Debug, Default)] pub struct DefineInput { pub var: Option>>>, pub command: Option>>, @@ -135,7 +135,7 @@ lazy_static! { } impl Define { - fn expand(&mut self, binding: BindingInput) -> ResultVec { + pub fn expand(&mut self, binding: BindingInput) -> ResultVec { // resolve default values let binding = if let Some(ref default) = binding.default { let BindingReference(name) = default.as_ref(); @@ -229,132 +229,4 @@ mod tests { )])) ); } - - // #[test] - // fn parsing_resolved_variables() { - // let data = r#" - // [[var]] - // foo = 1 - - // [[var]] - // foo_string = "number-{{var.foo}}" - - // [[command]] - // id = "run_shebang" - // command = "shebang" - // args.a = 1 - // args.b = "{{var.foo_string}}" - - // [[bind]] - // id = "whole_shebang" - // key = "a" - // name = "the whole shebang" - // command = "runCommands" - // args.commands = ["{{command.run_shebang}}", "bar"] - // "#; - - // let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - // let bind_args = result - // .bind - // .get("whole_shebang") - // .as_ref() - // .unwrap() - // .args - // .as_ref() - // .unwrap(); - // let bind_commands = bind_args - // .get_ref() - // .get("commands") - // .unwrap() - // .as_array() - // .unwrap(); - // assert_eq!( - // bind_commands[0].get("command").unwrap().as_str().unwrap(), - // "shebang" - // ); - // assert_eq!( - // bind_commands[0] - // .get("args") - // .unwrap() - // .get("b") - // .unwrap() - // .as_str() - // .unwrap(), - // "number-1" - // ); - // assert_eq!(bind_commands[1].as_str().unwrap(), "bar"); - // } - - // #[test] - // fn parsing_order_error() { - // let data = r#" - // [[var]] - // k = "{{command.foo}}" - - // [[var]] - // a = 1 - - // [[var]] - // b = "{{var.a}}-boot" - - // [[command]] - // id = "foo" - // command = "joe" - // args.x = 1 - - // [[command]] - // id = "bar" - // command = "runCommands" - // args.commands = ["{{command.biz}}", "baz"] - - // [[command]] - // id = "biz" - // command = "bob" - // args.y = 2 - // args.x = "{{bind.horace}}" - - // [[bind]] - // id = "horace" - // key = "ctrl+k" - // command = "cursorLeft" - // args.value = "{{count}}" - - // [[bind]] - // default = "{{bind.horace}}" - // id = "bob" - // key = "ctrl+y" - // command = "cursorRight" - - // [[bind]] - // default = "{{bind.will}}" - // id = "bob" - // key = "ctrl+k" - // command = "cursorDown" - // "#; - // // TODO: add `default` key to `bind` so we can accomplish the todo below - // // TODO: test for missing `bind` - // let result = Define::new(toml::from_str::(data).unwrap()).unwrap_err(); - // assert!(if let Error::ForwardReference(ref str) = result[0].error { - // str.starts_with("`command.foo`") - // } else { - // false - // }); - // assert!(if let Error::Constraint(ref str) = result[1].error { - // str.starts_with("no references to `var`") - // } else { - // false - // }); - // assert!(if let Error::UndefinedVariable(ref str) = result[2].error { - // str.starts_with("`command.biz`") - // } else { - // false - // }); - // assert!(if let Error::ForwardReference(ref str) = result[3].error { - // str.starts_with("`bind.horace`") - // } else { - // false - // }); - // info!("result: {:#?}", result); - // assert_eq!(result.len(), 4); - // } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index b237133e..16634db0 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,7 +1,7 @@ // top-level parsing of an entire file use crate::bind::{Binding, BindingInput}; -// use crate::define::{Define, DefineInput, VariableResolver}; -use crate::error::{ErrorContext, ErrorReport, ResultVec}; +use crate::define::{Define, DefineInput}; +use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; use log::info; use serde::{Deserialize, Serialize}; @@ -11,7 +11,7 @@ use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript #[derive(Deserialize, Clone, Debug)] struct KeyFileInput { - // define: Option, + define: Option, bind: Option>>, } @@ -19,126 +19,132 @@ struct KeyFileInput { #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct KeyFile { - // pub define: Define, + pub define: Define, pub bind: Vec, } -// impl KeyFile { -// fn new(mut input: KeyFileInput) -> ResultVec { -// let mut errors = Vec::new(); - -// // let define = input -// // .define -// // .map(|define| { -// // Define::new(define) -// // .map_err(|es| { -// // for e in es.into_iter() { -// // errors.push(e); -// // } -// // }) -// // .ok() -// // }) -// // .flatten() -// // .unwrap_or_default(); - -// // TODO: expand each define using the other known definitions -// // (with some limit on the number of iterations to resolved) -// // define.resolve_variables(&mut input.bind)?; - -// let bind = input -// .bind -// .map(|bindings| { -// return bindings -// .into_iter() -// .filter_map(|b| { -// let span = b.span(); -// let result = Binding::new(b.into_inner()).context_range(&span); -// result.map_err(|e| errors.push(e)).ok() -// }) -// .collect(); -// }) -// .unwrap_or_default(); - -// if errors.len() == 0 { -// return Ok(KeyFile { -// bind, -// // define -// }); -// } else { -// return Err(errors); -// } -// } -// } - -// #[wasm_bindgen(getter_with_clone)] -// pub struct KeyFileResult { -// pub file: Option, -// pub errors: Option>, -// } - -// #[wasm_bindgen] -// pub fn parse_string(file_content: &str) -> KeyFileResult { -// return match parse_string_helper(file_content) { -// Ok(result) => KeyFileResult { -// file: Some(result), -// errors: None, -// }, -// Err(err) => KeyFileResult { -// file: None, -// errors: Some(err.iter().map(|e| e.report(file_content)).collect()), -// }, -// }; -// } - -// fn parse_string_helper(file_content: &str) -> ResultVec { -// let parsed = toml::from_str::(file_content); -// return match parsed { -// Ok(input) => KeyFile::new(input), -// Err(err) => Err(vec![err.into()]), -// }; -// } - -// #[cfg(test)] -// mod tests { -// use super::*; -// // use test_log::test; - -// #[test] -// fn parse_example() { -// let data = r#" -// [[define.var]] -// foo = "bar" - -// [[bind]] -// key = "l" -// mode = "normal" -// command = "cursorRight" - -// [[bind]] -// key = "h" -// model = "normal" -// command = "cursorLeft" -// "#; - -// let result = parse_string(data); -// let items = result.file.as_ref().unwrap(); - -// assert_eq!(items.bind[0].key, "l"); -// assert_eq!(items.bind[0].commands[0].command, "cursorRight"); -// assert_eq!(items.bind[1].key, "h"); -// assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); - -// // assert_eq!( -// // items -// // .define -// // .var -// // .as_ref() -// // .unwrap() -// // .get("foo") -// // .unwrap() -// // .as_str() -// // .unwrap(), -// // "bar" -// // ) -// } -// } +impl KeyFile { + fn new(input: KeyFileInput) -> ResultVec { + let mut errors = Vec::new(); + let define_input = input.define.unwrap_or_default(); + let mut define = match Define::new(define_input) { + Err(mut es) => { + errors.append(&mut es.errors); + Define::default() + } + Ok(x) => x, + }; + + let bind_input = match flatten_errors( + input + .bind + .into_iter() + .flatten() + .map(|x| define.expand(x.into_inner())), + ) { + Err(mut es) => { + errors.append(&mut es.errors); + Vec::new() + } + Ok(x) => x, + }; + + let bind = match flatten_errors(bind_input.into_iter().map(|x| Binding::new(x))) { + Err(mut es) => { + errors.append(&mut es.errors); + Vec::new() + } + Ok(x) => x, + }; + + if errors.len() == 0 { + return Ok(KeyFile { define, bind }); + } else { + return Err(errors.into()); + } + } +} + +#[wasm_bindgen(getter_with_clone)] +pub struct KeyFileResult { + pub file: Option, + pub errors: Option>, +} + +#[wasm_bindgen] +pub fn parse_string(file_content: &str) -> KeyFileResult { + return match parse_string_helper(file_content) { + Ok(result) => KeyFileResult { + file: Some(result), + errors: None, + }, + Err(err) => KeyFileResult { + file: None, + errors: Some(err.errors.iter().map(|e| e.report(file_content)).collect()), + }, + }; +} + +fn parse_string_helper(file_content: &str) -> ResultVec { + let parsed = toml::from_str::(file_content)?; + return KeyFile::new(parsed); +} + +#[cfg(test)] +mod tests { + use super::*; + use test_log::test; + + #[test] + fn parse_example() { + let data = r#" + [[define.var]] + foo = "bar" + + [[bind]] + key = "l" + mode = "normal" + command = "cursorRight" + + [[bind]] + key = "h" + model = "normal" + command = "cursorLeft" + "#; + + let result = parse_string(data); + let items = result.file.unwrap(); + + assert_eq!(items.bind[0].key, "l"); + assert_eq!(items.bind[0].commands[0].command, "cursorRight"); + assert_eq!(items.bind[1].key, "h"); + assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); + } + + // #[test] + // fn parsing_resolved_bind_and_command() { + // let data = r#" + + // [[define.var]] + // foo_string = "bizbaz" + + // [[define.command]] + // id = "run_shebang" + // command = "shebang" + // args.a = 1 + // args.b = "{{var.foo_string}}" + + // [[define.bind]] + // id = "whole_shebang" + // name = "the whole shebang" + // command = "runCommands" + // args.commands = ["{{command.run_shebang}}", "bar"] + + // [[bind]] + // default = "{{whole_shebang}}" + // key = "a" + // "#; + + // // TODO + // } +} From a572b8920ee0aa0ccd4611592202ebd63d32b33f Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 5 Sep 2025 23:44:45 -0400 Subject: [PATCH 40/79] wip expression evaluation Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 76 +++++----- notes.md | 22 ++- src/presets/larkin.toml | 6 +- src/rust/parsing/src/bind.rs | 190 ++++++++++++++++++++---- src/rust/parsing/src/bind/foreach.rs | 2 +- src/rust/parsing/src/bind/validation.rs | 17 ++- src/rust/parsing/src/define.rs | 11 +- src/rust/parsing/src/error.rs | 6 + src/rust/parsing/src/file.rs | 97 +++++++++--- src/rust/parsing/src/value.rs | 53 +++---- 10 files changed, 343 insertions(+), 137 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 5db09442..b4827db7 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#e35b35", - "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#e35b35", - "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#f06842", - "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#fd754f", - "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#e35b35", - "statusBar.foreground": "#ffffff", - "statusBar.border": "#e35b35", - "statusBar.debuggingBackground": "#e35b35", - "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#e35b35", - "statusBar.noFolderBackground": "#e35b35", - "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#e35b35", - "statusBar.prominentBackground": "#e35b35", - "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#e35b35", - "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#e35b3599", - "progressBar.background": "#e35b35", - "textLink.foreground": "#ff9b75", - "textLink.activeForeground": "#ffa882", - "selection.background": "#d64e28", - "list.highlightForeground": "#e35b35", - "list.focusAndSelectionOutline": "#e35b3599", - "button.background": "#e35b35", - "button.foreground": "#ffffff", - "button.hoverBackground": "#f06842", - "tab.activeBorderTop": "#f06842", - "pickerGroup.foreground": "#f06842", - "list.activeSelectionBackground": "#e35b354d", - "panelTitle.activeBorder": "#f06842", - "activityBar.activeBorder": "#e35b35", - "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#e35b35" + "statusBarItem.warningBackground": "#1eca12", + "statusBarItem.warningForeground": "#000000", + "statusBarItem.warningHoverBackground": "#1eca12", + "statusBarItem.warningHoverForeground": "#00000090", + "statusBarItem.remoteBackground": "#2bd71f", + "statusBarItem.remoteForeground": "#000000", + "statusBarItem.remoteHoverBackground": "#38e42c", + "statusBarItem.remoteHoverForeground": "#00000090", + "statusBar.background": "#1eca12", + "statusBar.foreground": "#000000", + "statusBar.border": "#1eca12", + "statusBar.debuggingBackground": "#1eca12", + "statusBar.debuggingForeground": "#000000", + "statusBar.debuggingBorder": "#1eca12", + "statusBar.noFolderBackground": "#1eca12", + "statusBar.noFolderForeground": "#000000", + "statusBar.noFolderBorder": "#1eca12", + "statusBar.prominentBackground": "#1eca12", + "statusBar.prominentForeground": "#000000", + "statusBar.prominentHoverBackground": "#1eca12", + "statusBar.prominentHoverForeground": "#00000090", + "focusBorder": "#1eca1299", + "progressBar.background": "#1eca12", + "textLink.foreground": "#5eff52", + "textLink.activeForeground": "#6bff5f", + "selection.background": "#11bd05", + "list.highlightForeground": "#1eca12", + "list.focusAndSelectionOutline": "#1eca1299", + "button.background": "#1eca12", + "button.foreground": "#000000", + "button.hoverBackground": "#2bd71f", + "tab.activeBorderTop": "#2bd71f", + "pickerGroup.foreground": "#2bd71f", + "list.activeSelectionBackground": "#1eca124d", + "panelTitle.activeBorder": "#2bd71f", + "activityBar.activeBorder": "#1eca12", + "activityBarBadge.foreground": "#000000", + "activityBarBadge.background": "#1eca12" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/notes.md b/notes.md index 4c1208b6..0b6e9076 100644 --- a/notes.md +++ b/notes.md @@ -99,20 +99,25 @@ Integration test debugging: - [X] make sure to error on fields that cannot have runtime computation (only certain fields can be evaluated at runtime: `args` and `repeat`) - [X] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - - [ ] get evaluation of computed elements working `Command` and `Bind` working - - [ ] use rhai to implement expression evaluation - - [ ] preparse all `{{}}` into - - [ ] evaluate expressions + - [X] get evaluation of computed elements working `Command` and `Bind` working + - [ ] use rhai to implement expression evaluation + - [ ] setup state object definitions + - [ ] verify they can be called from typescript to evaluate an expression + - [ ] preparse all `{{}}` into + - [ ] evaluate expressions in command etc... + - [ ] foreach expansion within a KeyFile context - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls - [ ] implementation - [ ] unit tests - [X] basic parsing - - [ ] define expansion for `bind.` and `command.` + - [X] define expansion for `bind.` and `command.` + - [ ] command expansion from program state - [ ] try it out from extension debugging - [ ] write an integration test - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - - [ ] foreach expansion within a KeyFile context + - [ ] implement support for tags on `bind` (for filter them) + - [ ] implement support for `skipWhen` in `command` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls @@ -129,6 +134,7 @@ Integration test debugging: - [ ] proper conversion to keybindings.json command - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause + - [ ] implement `replay` - [ ] extraction of visual docs - [ ] extraction of markdown docs - [ ] extract all comment regions (exclude `#-`) @@ -136,12 +142,14 @@ Integration test debugging: - [ ] identify each non-comment region, and look for parsed elements whose span overlaps - [ ] convert any bind elements in this overlap into markdown table + - [ ] serialization of bindings to settings.json - [ ] actually replace javascript behavior with rust functions - [ ] CI - [x] setup CI unit tests for rust - [x] setup rust coverage - [x] setup CI and merge coverage across rust and javascript - - [ ] verify that CI is running and coverage is showing up + - [X] verify that CI is running and coverage is showing up + - [ ] check in with CI setup once we get the above tasks completed 4. Move palette from quick pick to tree view - [ ] get a simple tree view working (just show one item) diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 42de6dbc..2553732a 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -82,17 +82,17 @@ id = "selectLinesDown" command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" }, abort = "{{count <= 0}}" }, + { skipWhen = "{{count <= 0}}", command = "cursorMove", args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" } }, "expandLineSelection", "selection-utilities.exchangeAnchorActive", ] [[define.command]] id = "selectLinesUp" -command = "selection-utilities.shrinkToActive" +command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" }, abort = "{{count <= 0}}" }, + { skipWhen = "{{count <= 0}}", command = "cursorMove", args = { to = "up", by = "wrappedLine", select = true, value = "{{count}}" } }, "expandLineSelection", ] diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index e6255e9e..9c0dca61 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -1,19 +1,15 @@ -// parsing of individual `[[bind]]` elements - #![allow(non_snake_case)] #[allow(unused_imports)] use log::info; -use std::convert::identity; - +use std::collections::HashMap; use std::collections::VecDeque; -use std::error; +use std::convert::identity; use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use serde_wasm_bindgen; -use std::io; use toml::Spanned; use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; @@ -23,9 +19,8 @@ pub mod validation; use crate::bind::foreach::expand_keys; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::ErrorsWithContext; use crate::error::{Error, ErrorContext, Result, ResultVec, constrain, reserved, unexpected}; -use crate::util::{Merging, Plural, Required, Requiring, Resolving}; +use crate::util::{Merging, Plural, Required, Resolving}; use crate::value::{Expanding, TypedValue, Value}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; @@ -326,9 +321,9 @@ impl Expanding for CommandInput { } return true; } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { let mut errors = Vec::new(); let result = CommandInput { @@ -377,20 +372,130 @@ impl From for Value { #[wasm_bindgen(getter_with_clone)] #[derive(Clone, Debug, Serialize)] pub struct Command { - pub(crate) command: String, + pub command: String, pub(crate) args: Value, } // TODO: here is where we would want to invoke rhai to resolve any outstanding expressions + #[wasm_bindgen] -impl Command { - pub fn command(&self) -> std::result::Result { - return Ok("TODO".into()); +pub struct Scope { + asts: HashMap, + engine: rhai::Engine, + state: rhai::Scope<'static>, + queues: HashMap>, +} + +// TODO: we'll need to define `CustomType` on `Value` and `Command` +#[wasm_bindgen] +impl Scope { + // TODO: incorporate command queues + fn expand(&mut self, obj: &T) -> ResultVec + where + T: Expanding + Clone, + { + for (k, v) in self.queues.iter() { + // TODO: tell engine how to handle dequeues + // TODO: I don't love that we have to copy the queue for every evaluation + // there's probalby a better solution here + self.state.set_or_push(k, v.clone()); + } + return Ok(obj.clone().map_expressions(&mut |expr| { + let ast = &self.asts[&expr]; + let result = self.engine.eval_ast_with_scope(&mut self.state, &ast); + let value: rhai::Dynamic = match result { + Err(x) => Err(Error::ExpressionEval(format!("{}", x)))?, + Ok(x) => x, + }; + let result_value: Value = match value.clone().try_cast_result() { + Err(e) => Err(Error::Rhai(format!("{}", e)))?, + Ok(x) => x, + }; + return Ok(result_value); + })?); } + + fn parse_asts(&mut self, x: impl Expanding + Clone) -> ResultVec<()> { + x.clone().map_expressions(&mut |expr| { + let ast = self.engine.compile_expression(expr.clone())?; + self.asts.insert(expr.clone(), ast); + return Ok(Value::Expression(expr)); + })?; + return Ok(()); + } + + #[wasm_bindgen(constructor)] + pub fn new() -> Scope { + let engine = rhai::Engine::new(); + + return Scope { + asts: HashMap::new(), + engine: engine, + state: rhai::Scope::new(), + queues: HashMap::new(), + }; + } + + pub fn set(&mut self, name: String, value: JsValue) -> Result<()> { + let toml: toml::Value = match serde_wasm_bindgen::from_value(value) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => x, + }; + let val: Value = toml.try_into()?; + self.state.set_or_push(&name, val); + return Ok(()); + } + + pub fn unset(&mut self, name: String) -> Result<()> { + return Ok(self + .state + .remove(&name) + .ok_or_else(|| Error::UndefinedVariable(name))?); + } + + pub fn get(&self, name: String) -> Result { + let x: &rhai::Dynamic = self + .state + .get(&name) + .ok_or_else(|| Error::UndefinedVariable(name))?; + let x: Value = match x.clone().try_cast_result() { + Err(e) => Err(Error::Rhai(format!("{}", e)))?, + Ok(x) => x, + }; + let x: toml::Value = x.into(); + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + return match x.serialize(&to_json) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => Ok(x), + }; + } + + pub fn add_to_command_queue(&mut self, queue: String, x: Command) { + let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); + queue.push_back(x); + // TODO: pop queue if it gets too large + } + + pub fn pop_command_queue(&mut self, queue: String) -> Option { + let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); + return queue.pop_front(); + } + + // TODO: function to evaluate args of replay and return a range of expressions + // to replay in type script +} + +#[wasm_bindgen] +impl Command { #[wasm_bindgen(getter)] - pub fn args(&self) -> std::result::Result { + pub fn args(&self, scope: &mut Scope) -> ResultVec { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - return self.args.serialize(&to_json); + let flat_args = scope.expand(&self.args)?; + + return match toml::Value::from(flat_args).serialize(&to_json) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => Ok(x), + }; } } @@ -409,7 +514,6 @@ impl Command { } } -// TODO: have Value and Value #[derive(Clone, Debug, Serialize)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] @@ -462,7 +566,7 @@ impl BindingInput { let mut result = self.clone(); result.foreach = None; result - .map_expressions(&|x| { + .map_expressions(&mut |x| { Ok(values .get(&x) .map_or_else(|| Value::Expression(x), |ex| ex.clone())) @@ -520,9 +624,9 @@ impl Expanding for BindingInput { .into_iter() .all(identity) } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { let mut errors = Vec::new(); let result = BindingInput { @@ -703,8 +807,16 @@ fn regularize_commands(input: &BindingInput) -> ResultVec> { } } +#[wasm_bindgen] impl Binding { - pub fn new(input: BindingInput) -> ResultVec { + pub fn repeat(&mut self, scope: &mut Scope) -> ResultVec { + return match scope.expand(&self.repeat)? { + None => Ok(0), + Some(val) => Ok(val.into()), + }; + } + + pub(crate) fn new(input: BindingInput) -> ResultVec { if let Some(_) = input.id { return reserved("id")?; } @@ -747,7 +859,6 @@ impl Binding { #[cfg(test)] mod tests { - use std::{collections::HashMap, io::Write}; use test_log::test; use super::*; @@ -775,8 +886,6 @@ mod tests { kind = "biz" "#; - io::stdout().flush().unwrap(); - let result = toml::from_str::(data).unwrap(); assert_eq!( @@ -807,7 +916,7 @@ mod tests { assert_eq!(priority, 1.0); assert_eq!( result.default.unwrap().into_inner().0, - "bind.foo_bar".to_string() + "foo_bar".to_string() ); let foreach = result.foreach.unwrap(); let values = foreach.get("index").unwrap(); @@ -1082,6 +1191,37 @@ mod tests { } } + // TODO: implement functions that don't require WASM runtime + // to test here, and then test JS wrapped functions in integration tests + #[test] + fn expand_args() { + let data = r#" + key = "k" + name = "test" + command = "foo" + args.value = '{{joe + "_biz"}}' + args.number = '{{2+1}}' + "#; + + let result = Binding::new(toml::from_str::(data).unwrap()).unwrap(); + let mut scope = Scope::new(); + scope.set("joe".to_string(), JsValue::from_str("fiz")); + let flat_args = result.commands[0].args(&mut scope).unwrap(); + + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + let mut args_table = toml::map::Map::new(); + args_table.insert( + "value".to_string(), + toml::Value::String("fiz_biz".to_string()), + ); + args_table.insert("number".to_string(), toml::Value::Integer(3)); + let expected = toml::Value::Table(args_table).serialize(&to_json).unwrap(); + + assert_eq!(flat_args, expected) + } + + // TODO: test out command queue evaluation in expressions + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 001989fc..b6fdced2 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -230,7 +230,7 @@ pub fn expand_keys( items: IndexMap>>, ) -> ResultVec>> { // expand any `{{key(`regex`)}}` expressions (these are arrays of possible keys) - let items = items.map_expressions(&expand_keys_str)?; + let items = items.map_expressions(&mut expand_keys_str)?; // flatten any arrays return Ok(items diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 937c1d84..afdf6123 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -145,9 +145,9 @@ impl Expanding for KeyBinding { KeyBinding(TypedValue::Variable(_)) => false, } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { Ok(match self { KeyBinding(TypedValue::Constant(ref x)) => self, @@ -205,12 +205,15 @@ impl TryFrom for BindingReference { let value: Value = toml::Value::String(value).try_into()?; match value { Value::Expression(x) => { - if !BIND_VARIABLE.is_match(&x) { + if let Some(captures) = BIND_VARIABLE.captures(&x) { + Ok(BindingReference( + captures.get(1).expect("variable name").as_str().to_string(), + )) + } else { Err(Error::Validation( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), - ))?; + ))? } - return Ok(BindingReference(x)); } _ => Err(Error::Validation( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), @@ -227,10 +230,10 @@ impl Expanding for BindingReference { fn is_constant(&self) -> bool { false } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where Self: Sized, - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { return Ok(self); } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 42c246df..056687e7 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -7,7 +7,7 @@ use crate::bind::validation::BindingReference; use crate::bind::{Binding, BindingInput, Command, CommandInput}; use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; use crate::util::{Merging, Resolving}; -use crate::value::{Expander, Expanding, Value}; +use crate::value::{Expanding, Value}; use indexmap::IndexMap; use lazy_static::lazy_static; @@ -157,11 +157,16 @@ impl Define { binding }; - return binding.map_expressions(&|exp: String| { + return binding.map_expressions(&mut |exp: String| { let command = COMMAND_REF.captures(&exp); if let Some(captures) = command { let name = captures.get(1).expect("variable name").as_str(); - return Ok(self.command[name].without_id().into()); + return Ok(self + .command + .get(name) + .ok_or_else(|| Error::UndefinedVariable(name.to_string()))? + .without_id() + .into()); } if BIND_REF.is_match(&exp) { Err(Error::Constraint( diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 9b2c83fe..eedc4207 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -16,8 +16,14 @@ pub enum Error { TomlParsing(#[from] toml::de::Error), #[error("expression parsing {0}")] ExpressionParsing(#[from] rhai::ParseError), + #[error("expression eval {0}")] + ExpressionEval(String), #[error("serializing {0}")] Serialization(#[from] toml::ser::Error), + #[error("deserializing {0}")] + JsSerialization(String), + #[error("expression failed with {0}")] + Rhai(String), #[error("invalid {0}")] Validation(String), #[error("expected {0}")] diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 16634db0..c1d9f997 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -2,6 +2,7 @@ use crate::bind::{Binding, BindingInput}; use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; +use crate::value::Value; use log::info; use serde::{Deserialize, Serialize}; @@ -93,6 +94,7 @@ fn parse_string_helper(file_content: &str) -> ResultVec { #[cfg(test)] mod tests { use super::*; + use indexmap::IndexMap; use test_log::test; #[test] @@ -121,30 +123,83 @@ mod tests { assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); } - // #[test] - // fn parsing_resolved_bind_and_command() { - // let data = r#" + #[test] + fn resolve_bind_and_command() { + let data = r#" - // [[define.var]] - // foo_string = "bizbaz" + [[define.var]] + foo_string = "bizbaz" - // [[define.command]] - // id = "run_shebang" - // command = "shebang" - // args.a = 1 - // args.b = "{{var.foo_string}}" + [[define.command]] + id = "run_shebang" + command = "shebang" + args.a = 1 + args.b = "{{var.foo_string}}" - // [[define.bind]] - // id = "whole_shebang" - // name = "the whole shebang" - // command = "runCommands" - // args.commands = ["{{command.run_shebang}}", "bar"] + [[define.bind]] + id = "whole_shebang" + name = "the whole shebang" + command = "runCommands" + args.commands = ["{{command.run_shebang}}", "bar"] - // [[bind]] - // default = "{{whole_shebang}}" - // key = "a" - // "#; + [[bind]] + default = "{{bind.whole_shebang}}" + key = "a" + "#; - // // TODO - // } + let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + + assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + assert_eq!(result.bind[0].key, "a"); + assert_eq!(result.bind[0].commands[0].command, "shebang"); + assert_eq!( + result.bind[0].commands[0].args, + Value::Table(IndexMap::from([ + ("a".into(), Value::Integer(1)), + ("b".into(), Value::Expression("var.foo_string".into())), + ])) + ); + assert_eq!(result.bind[0].commands[1].command, "bar"); + } + + #[test] + fn resolve_nested_command() { + let data = r#" + + [[define.command]] + id = "run_shebang" + command = "shebang" + args.a = 1 + args.b = "{{var.foo_string}}" + + [[define.bind]] + id = "a" + args.commands = ["{{command.run_shebang}}", "bar"] + + [[define.bind]] + id = "b" + key = "x" + command = "runCommands" + default = "{{bind.a}}" + + [[bind]] + default = "{{bind.b}}" + name = "the whole shebang" + key = "a" + "#; + + let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + + assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + assert_eq!(result.bind[0].key, "a"); + assert_eq!(result.bind[0].commands[0].command, "shebang"); + assert_eq!( + result.bind[0].commands[0].args, + Value::Table(IndexMap::from([ + ("a".into(), Value::Integer(1)), + ("b".into(), Value::Expression("var.foo_string".into())), + ])) + ); + assert_eq!(result.bind[0].commands[1].command, "bar"); + } } diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs index af81919a..801d3271 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/value.rs @@ -21,13 +21,6 @@ use crate::error::{ }; use crate::util::{Merging, Plural, Required, Resolving}; -// TODO: implement Expanding type - -pub enum ExpandResult { - Expanded(Value), - Deferred, -} - // TODO: implement Float / Integer, and deal with regularizing that // to float64 only when we serialize to JSON (but still enforce the // boundary on integers in the same place we do now) @@ -41,6 +34,8 @@ pub enum Value { Array(Vec), Table(IndexMap), Interp(Vec), + // TODO: could optimize further by using an internned string (simplifying AST lookup) + // TODO: include a span so that we can improve error messages Expression(String), } @@ -144,24 +139,18 @@ impl Merging for Value { } } -pub trait Expander { - fn expand(self, x: T) -> ResultVec - where - T: Expanding + Merging; -} - pub trait Expanding { - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where Self: Sized, - F: Fn(String) -> Result; + F: FnMut(String) -> Result; fn is_constant(&self) -> bool; fn require_constant(&self) -> ResultVec<()> where Self: Sized + Clone, { - self.clone().map_expressions(&|e| { + self.clone().map_expressions(&mut |e| { Err(Error::Unresolved(format!("Unresolved expression {e}")).into()) })?; return Ok(()); @@ -172,9 +161,9 @@ impl Expanding for IndexMap { fn is_constant(&self) -> bool { self.values().all(|v| v.is_constant()) } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { return Ok(flatten_errors( self.into_iter() @@ -195,9 +184,9 @@ impl Expanding for Value { Value::Boolean(_) | Value::Float(_) | Value::Integer(_) | Value::String(_) => true, } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { // XXX: we could optimize by pruning constant branches return Ok(match self { @@ -304,9 +293,9 @@ where TypedValue::Variable(_) => false, } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { return Ok(match self { TypedValue::Variable(v) => { @@ -416,9 +405,9 @@ impl Expanding for Spanned { fn is_constant(&self) -> bool { self.as_ref().is_constant() } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { let span = self.span(); Ok(Spanned::new( @@ -432,9 +421,9 @@ impl Expanding for Vec { fn is_constant(&self) -> bool { self.iter().all(|x| x.is_constant()) } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { Ok(flatten_errors( self.into_iter().map(|x| x.map_expressions(f)), @@ -450,9 +439,9 @@ impl Expanding for Plural { Plural::Many(xs) => xs.iter().all(|x| x.is_constant()), } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { Ok(match self { Plural::Zero => self, @@ -469,9 +458,9 @@ impl Expanding for Required { Required::Value(x) => x.is_constant(), } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { return Ok(match self { Required::DefaultValue => self, @@ -487,9 +476,9 @@ impl Expanding for Option { Some(x) => x.is_constant(), } } - fn map_expressions(self, f: &F) -> ResultVec + fn map_expressions(self, f: &mut F) -> ResultVec where - F: Fn(String) -> Result, + F: FnMut(String) -> Result, { return Ok(match self { None => self, From 6ad50b7f74d0706cdfccdeea560e3ceb969d2673 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 6 Sep 2025 23:33:06 -0400 Subject: [PATCH 41/79] simple expression evaluation working Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 76 +++++++++++++++++------------------ notes.md | 14 ++++--- src/rust/parsing/src/bind.rs | 48 +++++++++++----------- src/rust/parsing/src/value.rs | 67 ++++++++++++++++++++++++++++++ 4 files changed, 137 insertions(+), 68 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index b4827db7..a8955c60 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -17,44 +17,44 @@ "editorBracketHighlight.foreground5": "#66a61e", "editorBracketHighlight.foreground6": "#e6ab02", "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#1eca12", - "statusBarItem.warningForeground": "#000000", - "statusBarItem.warningHoverBackground": "#1eca12", - "statusBarItem.warningHoverForeground": "#00000090", - "statusBarItem.remoteBackground": "#2bd71f", - "statusBarItem.remoteForeground": "#000000", - "statusBarItem.remoteHoverBackground": "#38e42c", - "statusBarItem.remoteHoverForeground": "#00000090", - "statusBar.background": "#1eca12", - "statusBar.foreground": "#000000", - "statusBar.border": "#1eca12", - "statusBar.debuggingBackground": "#1eca12", - "statusBar.debuggingForeground": "#000000", - "statusBar.debuggingBorder": "#1eca12", - "statusBar.noFolderBackground": "#1eca12", - "statusBar.noFolderForeground": "#000000", - "statusBar.noFolderBorder": "#1eca12", - "statusBar.prominentBackground": "#1eca12", - "statusBar.prominentForeground": "#000000", - "statusBar.prominentHoverBackground": "#1eca12", - "statusBar.prominentHoverForeground": "#00000090", - "focusBorder": "#1eca1299", - "progressBar.background": "#1eca12", - "textLink.foreground": "#5eff52", - "textLink.activeForeground": "#6bff5f", - "selection.background": "#11bd05", - "list.highlightForeground": "#1eca12", - "list.focusAndSelectionOutline": "#1eca1299", - "button.background": "#1eca12", - "button.foreground": "#000000", - "button.hoverBackground": "#2bd71f", - "tab.activeBorderTop": "#2bd71f", - "pickerGroup.foreground": "#2bd71f", - "list.activeSelectionBackground": "#1eca124d", - "panelTitle.activeBorder": "#2bd71f", - "activityBar.activeBorder": "#1eca12", - "activityBarBadge.foreground": "#000000", - "activityBarBadge.background": "#1eca12" + "statusBarItem.warningBackground": "#3012f8", + "statusBarItem.warningForeground": "#ffffff", + "statusBarItem.warningHoverBackground": "#3012f8", + "statusBarItem.warningHoverForeground": "#ffffff90", + "statusBarItem.remoteBackground": "#3d1fff", + "statusBarItem.remoteForeground": "#ffffff", + "statusBarItem.remoteHoverBackground": "#4a2cff", + "statusBarItem.remoteHoverForeground": "#ffffff90", + "statusBar.background": "#3012f8", + "statusBar.foreground": "#ffffff", + "statusBar.border": "#3012f8", + "statusBar.debuggingBackground": "#3012f8", + "statusBar.debuggingForeground": "#ffffff", + "statusBar.debuggingBorder": "#3012f8", + "statusBar.noFolderBackground": "#3012f8", + "statusBar.noFolderForeground": "#ffffff", + "statusBar.noFolderBorder": "#3012f8", + "statusBar.prominentBackground": "#3012f8", + "statusBar.prominentForeground": "#ffffff", + "statusBar.prominentHoverBackground": "#3012f8", + "statusBar.prominentHoverForeground": "#ffffff90", + "focusBorder": "#3012f899", + "progressBar.background": "#3012f8", + "textLink.foreground": "#7052ff", + "textLink.activeForeground": "#7d5fff", + "selection.background": "#2305eb", + "list.highlightForeground": "#3012f8", + "list.focusAndSelectionOutline": "#3012f899", + "button.background": "#3012f8", + "button.foreground": "#ffffff", + "button.hoverBackground": "#3d1fff", + "tab.activeBorderTop": "#3d1fff", + "pickerGroup.foreground": "#3d1fff", + "list.activeSelectionBackground": "#3012f84d", + "panelTitle.activeBorder": "#3d1fff", + "activityBar.activeBorder": "#3012f8", + "activityBarBadge.foreground": "#ffffff", + "activityBarBadge.background": "#3012f8" }, "window.title": "vscode-master-key", "projectColors.name": "vscode-master-key", diff --git a/notes.md b/notes.md index 0b6e9076..3fc4237b 100644 --- a/notes.md +++ b/notes.md @@ -100,11 +100,10 @@ Integration test debugging: (only certain fields can be evaluated at runtime: `args` and `repeat`) - [X] get basic interpolation of `{{bind/command}}` from `define` elements working for `bind` and its fields - [X] get evaluation of computed elements working `Command` and `Bind` working - - [ ] use rhai to implement expression evaluation - - [ ] setup state object definitions - - [ ] verify they can be called from typescript to evaluate an expression - - [ ] preparse all `{{}}` into - - [ ] evaluate expressions in command etc... + - [X] use rhai to implement expression evaluation + - [X] setup state object definitions + - [X] preparse all `{{}}` into AST + - [X] evaluate expressions in command etc... - [ ] foreach expansion within a KeyFile context - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls - [ ] implementation @@ -113,11 +112,14 @@ Integration test debugging: - [X] define expansion for `bind.` and `command.` - [ ] command expansion from program state - [ ] try it out from extension debugging - - [ ] write an integration test + - [ ] write some integration tests - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring + - [ ] fix and test command queues implementation + - [ ] replace IndexMap with BTreeMap - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` + - [ ] implement support for `{{all_prefixes()}}` and `{{all_modes()}}` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 9c0dca61..4715f66f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -2,6 +2,7 @@ #[allow(unused_imports)] use log::info; +use rhai::Dynamic; use std::collections::HashMap; use std::collections::VecDeque; @@ -397,7 +398,11 @@ impl Scope { for (k, v) in self.queues.iter() { // TODO: tell engine how to handle dequeues // TODO: I don't love that we have to copy the queue for every evaluation - // there's probalby a better solution here + // this will have to be fixed to avoid ridiculous amounts of copying + // per command run + + // PLAN: make queue type a CustomType and track it in `state` instead of + // in `queues`. self.state.set_or_push(k, v.clone()); } return Ok(obj.clone().map_expressions(&mut |expr| { @@ -407,15 +412,12 @@ impl Scope { Err(x) => Err(Error::ExpressionEval(format!("{}", x)))?, Ok(x) => x, }; - let result_value: Value = match value.clone().try_cast_result() { - Err(e) => Err(Error::Rhai(format!("{}", e)))?, - Ok(x) => x, - }; + let result_value: Value = value.clone().try_into()?; return Ok(result_value); })?); } - fn parse_asts(&mut self, x: impl Expanding + Clone) -> ResultVec<()> { + fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { x.clone().map_expressions(&mut |expr| { let ast = self.engine.compile_expression(expr.clone())?; self.asts.insert(expr.clone(), ast); @@ -442,6 +444,7 @@ impl Scope { Ok(x) => x, }; let val: Value = toml.try_into()?; + let val: Dynamic = val.into(); self.state.set_or_push(&name, val); return Ok(()); } @@ -487,12 +490,14 @@ impl Scope { #[wasm_bindgen] impl Command { - #[wasm_bindgen(getter)] - pub fn args(&self, scope: &mut Scope) -> ResultVec { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + pub(crate) fn toml_args(&self, scope: &mut Scope) -> ResultVec { let flat_args = scope.expand(&self.args)?; + return Ok(toml::Value::from(flat_args)); + } - return match toml::Value::from(flat_args).serialize(&to_json) { + pub fn args(&self, scope: &mut Scope) -> ResultVec { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + return match self.toml_args(scope)?.serialize(&to_json) { Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, Ok(x) => Ok(x), }; @@ -1191,8 +1196,6 @@ mod tests { } } - // TODO: implement functions that don't require WASM runtime - // to test here, and then test JS wrapped functions in integration tests #[test] fn expand_args() { let data = r#" @@ -1203,25 +1206,22 @@ mod tests { args.number = '{{2+1}}' "#; - let result = Binding::new(toml::from_str::(data).unwrap()).unwrap(); + let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - scope.set("joe".to_string(), JsValue::from_str("fiz")); - let flat_args = result.commands[0].args(&mut scope).unwrap(); + scope.parse_asts(&input); + let result = Binding::new(input).unwrap(); + scope.state.set_or_push("joe", Dynamic::from("fiz")); + let flat_args = result.commands[0].toml_args(&mut scope).unwrap(); - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - let mut args_table = toml::map::Map::new(); - args_table.insert( + let mut args_expected = toml::map::Map::new(); + args_expected.insert( "value".to_string(), toml::Value::String("fiz_biz".to_string()), ); - args_table.insert("number".to_string(), toml::Value::Integer(3)); - let expected = toml::Value::Table(args_table).serialize(&to_json).unwrap(); - - assert_eq!(flat_args, expected) + args_expected.insert("number".to_string(), toml::Value::Integer(3)); + assert_eq!(flat_args, toml::Value::Table(args_expected)); } - // TODO: test out command queue evaluation in expressions - // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/value.rs index 801d3271..6fb79b3e 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/value.rs @@ -11,6 +11,7 @@ use log::info; use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; +use rhai::Dynamic; use rhai::{AST, CustomType, Engine}; use serde::{Deserialize, Serialize}; use toml::Spanned; @@ -39,6 +40,72 @@ pub enum Value { Expression(String), } +impl From for Dynamic { + fn from(value: Value) -> Self { + return match value { + Value::Float(x) => Dynamic::from(x), + Value::Integer(x) => Dynamic::from(x), + Value::Boolean(x) => Dynamic::from(x), + Value::String(x) => Dynamic::from(x), + Value::Array(x) => { + let elements: Vec = x.into_iter().map(|x| Dynamic::from(x)).collect(); + elements.into() + } + Value::Table(x) => { + let map: std::collections::HashMap = + x.into_iter().map(|(k, v)| (k, v.into())).collect(); + map.into() + } + // the from here results in an opaque custom type + Value::Expression(x) => Dynamic::from(x), + Value::Interp(x) => Dynamic::from(x), + }; + } +} + +impl TryFrom for Value { + type Error = crate::error::ErrorWithContext; + // TODO: this is currently almost certainly quite inefficient (we clone arrays and + // maps), but we can worry about optimizing this later + fn try_from(value: Dynamic) -> Result { + if value.is_array() { + let elements = value.as_array_ref().expect("array value"); + let values = elements + .clone() + .into_iter() + .map(|x| Value::try_from(x.to_owned())) + .collect::>>()?; + return Ok(Value::Array(values)); + } else if value.is_map() { + let pairs = value.as_map_ref().expect("map value"); + let values = pairs + .clone() + .into_iter() + .map(|(k, v)| Ok((k.as_str().to_string(), Value::try_from(v.to_owned())?))) + .collect::>>()?; + return Ok(Value::Table(values)); + } else if value.is_bool() { + return Ok(Value::Boolean(value.as_bool().expect("boolean"))); + } else if value.is_float() { + return Ok(Value::Float(value.as_float().expect("float"))); + } else if value.is_int() { + return Ok(Value::Integer(value.as_int().expect("integer") as i32)); + } else if value.is_string() { + return Ok(Value::String( + value + .as_immutable_string_ref() + .expect("string") + .as_str() + .to_string(), + )); + } else { + Err(Error::Constraint(format!( + "usable script value; but {value} is unusable" + )))? + } + } +} + lazy_static! { pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*?)\}\}").unwrap(); } From de71085b39301222e5337459b09f3edfce634618 Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 7 Sep 2025 23:58:50 -0400 Subject: [PATCH 42/79] foreach error shows proper span Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 56 --------------- notes.md | 29 +++++--- src/extension/keybindings/index.ts | 35 +++++---- src/rust/parsing/src/file.rs | 112 +++++++++++++++++++++++++---- 4 files changed, 139 insertions(+), 93 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index a8955c60..d37a7a58 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,5 +1,4 @@ { - "editor.formatOnSave": true, "eslint.validate": [ "javascript", "javascriptreact", @@ -9,62 +8,7 @@ "rust-analyzer.linkedProjects": [ "src/rust/parsing/Cargo.toml" ], - "workbench.colorCustomizations": { - "editorBracketHighlight.foreground1": "#1b9e77", - "editorBracketHighlight.foreground2": "#d95f02", - "editorBracketHighlight.foreground3": "#7570b3", - "editorBracketHighlight.foreground4": "#e7298a", - "editorBracketHighlight.foreground5": "#66a61e", - "editorBracketHighlight.foreground6": "#e6ab02", - "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "statusBarItem.warningBackground": "#3012f8", - "statusBarItem.warningForeground": "#ffffff", - "statusBarItem.warningHoverBackground": "#3012f8", - "statusBarItem.warningHoverForeground": "#ffffff90", - "statusBarItem.remoteBackground": "#3d1fff", - "statusBarItem.remoteForeground": "#ffffff", - "statusBarItem.remoteHoverBackground": "#4a2cff", - "statusBarItem.remoteHoverForeground": "#ffffff90", - "statusBar.background": "#3012f8", - "statusBar.foreground": "#ffffff", - "statusBar.border": "#3012f8", - "statusBar.debuggingBackground": "#3012f8", - "statusBar.debuggingForeground": "#ffffff", - "statusBar.debuggingBorder": "#3012f8", - "statusBar.noFolderBackground": "#3012f8", - "statusBar.noFolderForeground": "#ffffff", - "statusBar.noFolderBorder": "#3012f8", - "statusBar.prominentBackground": "#3012f8", - "statusBar.prominentForeground": "#ffffff", - "statusBar.prominentHoverBackground": "#3012f8", - "statusBar.prominentHoverForeground": "#ffffff90", - "focusBorder": "#3012f899", - "progressBar.background": "#3012f8", - "textLink.foreground": "#7052ff", - "textLink.activeForeground": "#7d5fff", - "selection.background": "#2305eb", - "list.highlightForeground": "#3012f8", - "list.focusAndSelectionOutline": "#3012f899", - "button.background": "#3012f8", - "button.foreground": "#ffffff", - "button.hoverBackground": "#3d1fff", - "tab.activeBorderTop": "#3d1fff", - "pickerGroup.foreground": "#3d1fff", - "list.activeSelectionBackground": "#3012f84d", - "panelTitle.activeBorder": "#3d1fff", - "activityBar.activeBorder": "#3012f8", - "activityBarBadge.foreground": "#ffffff", - "activityBarBadge.background": "#3012f8" - }, "window.title": "vscode-master-key", - "projectColors.name": "vscode-master-key", - "projectColors.mainColor": "#31da1b", - "projectColors.isActivityBarColored": false, - "projectColors.isTitleBarColored": true, - "projectColors.isStatusBarColored": true, - "projectColors.isProjectNameColored": true, - "projectColors.isActiveItemsColored": true, - "projectColors.setWindowTitle": true, "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.88.0-aarch64-apple-darwin", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, diff --git a/notes.md b/notes.md index 3fc4237b..5e0396c6 100644 --- a/notes.md +++ b/notes.md @@ -104,18 +104,20 @@ Integration test debugging: - [X] setup state object definitions - [X] preparse all `{{}}` into AST - [X] evaluate expressions in command etc... - - [ ] foreach expansion within a KeyFile context + - [X] foreach expansion within a KeyFile context - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls - - [ ] implementation - - [ ] unit tests + - [X] implementation + - [X] unit tests - [X] basic parsing - [X] define expansion for `bind.` and `command.` - - [ ] command expansion from program state - [ ] try it out from extension debugging - [ ] write some integration tests - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - - [ ] fix and test command queues implementation + - [ ] re-organize the code into smaller units + - [ ] update documentation of `bind`, `define` and expressions + - [ ] update documentation rendering pipeline + - [ ] fix and test command queues implementation (avoid so much copying) - [ ] replace IndexMap with BTreeMap - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` @@ -123,20 +125,31 @@ Integration test debugging: - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls + - [ ] `skipWhen` will have to be propagated/merged to children - [ ] check constraints - [ ] validation that `master-key.prefix` uses `finalKey: false` - [ ] validation that keybindings with non modifier keybindings have a condition requiring textEditorFocus - [ ] modes are all positive or negative - [ ] required keys are present - - [ ] mode expansion - - [ ] key-sequence expansion and duplicate resolution + - [ ] mode expansion: define a key binding per mode + - [ ] key-sequence expansion and duplicate resolution: + - [ ] create a binding per key in a sequence that requires a given prefix + (depending on the prefix code of its prefix) + - [ ] add any missing prefixes - [ ] documentation expandsion/validation across all `[[bind]]` values with the same key and mode + e.g. merge all shared documentation across the shared names - [ ] proper conversion to keybindings.json command - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause - - [ ] implement `replay` + - [ ] re-implement master-key.do + - [ ] transfer scope state from TS to rust Scope object + - [ ] properly handle command queues (no controlled by rust) + - [ ] unit tests + - [ ] integration tests + - [ ] implement `replay`: use the new rust command queues instead of the old + state management - [ ] extraction of visual docs - [ ] extraction of markdown docs - [ ] extract all comment regions (exclude `#-`) diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 5875a093..61a204d0 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -656,28 +656,33 @@ async function validateKeybindings(file: vscode.Uri, fileString?: string) { const diagnosticItems: vscode.Diagnostic[] = []; for (const error of parsed.errors) { let message = ''; + let firstMessage = true; for (const item of error.items) { if (item.message) { message += item.message + '\n'; } if (item.range) { - diagnosticItems.push( - new vscode.Diagnostic( - new vscode.Range( - new vscode.Position( - item.range.start.line, - item.range.start.col, - ), - new vscode.Position( - item.range.end.line, - item.range.end.col, + if (message.length > 0) { + diagnosticItems.push( + new vscode.Diagnostic( + new vscode.Range( + new vscode.Position( + item.range.start.line, + item.range.start.col, + ), + new vscode.Position( + item.range.end.line, + item.range.end.col, + ), ), + message, + firstMessage ? vscode.DiagnosticSeverity.Error : + vscode.DiagnosticSeverity.Hint, ), - message, - vscode.DiagnosticSeverity.Error, - ), - ); - message = ''; + ); + firstMessage = false; + message = ''; + } } } if (message) { diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index c1d9f997..9dd44aa5 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -4,6 +4,7 @@ use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; use crate::value::Value; +use js_sys::Math::exp; use log::info; use serde::{Deserialize, Serialize}; use toml::Spanned; @@ -36,21 +37,13 @@ impl KeyFile { Ok(x) => x, }; - let bind_input = match flatten_errors( - input - .bind - .into_iter() - .flatten() - .map(|x| define.expand(x.into_inner())), - ) { - Err(mut es) => { - errors.append(&mut es.errors); - Vec::new() - } - Ok(x) => x, - }; + let input_iter = input + .bind + .into_iter() + .flatten() + .map(|x| Ok(Spanned::new(x.span(), define.expand(x.into_inner())?))); - let bind = match flatten_errors(bind_input.into_iter().map(|x| Binding::new(x))) { + let bind_input = match flatten_errors(input_iter) { Err(mut es) => { errors.append(&mut es.errors); Vec::new() @@ -58,6 +51,39 @@ impl KeyFile { Ok(x) => x, }; + let bind: Vec<_> = bind_input + .into_iter() + .flat_map(|x| { + let span = x.span().clone(); + match x.into_inner().expand_foreach() { + Ok(replicates) => { + // we resolve the foreach elements originating from a single item here, + // rather than expanding and flattening all errors. That's because we + // only want the first instance of an error at a given text span to show + // up in the final error output (e.g. if we have foreach.key = [1,2,3] + // we don't want an error about a missing required key to show up three + // times + let items = replicates + .into_iter() + .map(Binding::new) + .collect::>>() + .context_range(&span); + match items { + Ok(x) => x, + Err(mut e) => { + errors.append(&mut e.errors); + Vec::new() + } + } + } + Err(mut e) => { + errors.append(&mut e.errors); + Vec::new() + } + } + }) + .collect(); + if errors.len() == 0 { return Ok(KeyFile { define, bind }); } else { @@ -202,4 +228,62 @@ mod tests { ); assert_eq!(result.bind[0].commands[1].command, "bar"); } + + #[test] + fn expand_foreach() { + let data = r#" + [[bind]] + foreach.key = ["{{keys(`[0-9]`)}}"] + key = "c {{key}}" + name = "update {{key}}" + command = "foo" + args.value = "{{key}}" + "#; + + let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + + let expected_name: Vec = + (0..9).into_iter().map(|n| format!("update {n}")).collect(); + let expected_value: Vec = (0..9).into_iter().map(|n| format!("{}", n)).collect(); + + assert_eq!(result.bind.len(), 10); + for i in 0..9 { + assert_eq!( + result.bind[i].name.as_ref().unwrap().clone(), + expected_name[i] + ); + assert_eq!( + result.bind[i].commands[0].args, + Value::Table(IndexMap::from([( + "value".to_string(), + Value::String(expected_value[i].clone()) + ),])) + ); + } + } + + #[test] + fn foreach_error() { + let data = r#" + [[bind]] + foreach.key = ["{{keys(`[0-9]`)}}"] + name = "update {{key}}" + command = "foo" + args.value = "{{key}}" + "#; + + // TODO: ensure that a proper span is shown here + let result = KeyFile::new(toml::from_str::(data).unwrap()); + let report = result.unwrap_err().report(data); + assert_eq!( + report[0].items[0].message, + Some("requires `key` field".to_string()) + ); + assert_eq!(report[0].items[1].range.as_ref().unwrap().start.line, 1); + assert_eq!(report[0].items[1].range.as_ref().unwrap().end.line, 1); + } + + // TODO: write a test for required field `key` and ensure the span + // is narrowed to the appropriate `[[bind]]` element; also should only error once + // (right now we're erroring on the expanded value) } From 57a0c48ef53d21b4d2c086943486d9e0ef2f6b11 Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 8 Sep 2025 00:06:17 -0400 Subject: [PATCH 43/79] design of `all_modes_but` function Created using spr 1.3.6-beta.1 --- notes.md | 5 +++- src/presets/larkin.toml | 54 ++++++++++++++++++++--------------------- 2 files changed, 31 insertions(+), 28 deletions(-) diff --git a/notes.md b/notes.md index 5e0396c6..738dd54b 100644 --- a/notes.md +++ b/notes.md @@ -121,7 +121,10 @@ Integration test debugging: - [ ] replace IndexMap with BTreeMap - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` - - [ ] implement support for `{{all_prefixes()}}` and `{{all_modes()}}` + - [ ] implement support for `all` functions: + - [ ] `{{all_prefixes()}}` + - [ ] `{{all_modes()}}` + - [ ] `{{all_modes_but(["not_me", "or_me"])}}` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 2553732a..3bd5a0b8 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -114,8 +114,8 @@ key = "shift+;" name = "suggest" finalKey = false hideInPalette = true -prefixes = "{{all_prefixes}}" -mode = ["!capture", "!insert"] +prefixes = "{{all_prefixes()}}" +mode = '{{all_modes_but(["capture", "insert"]}}' description = """ show command suggestions within the context of the current mode and keybinding prefix (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that start with `TAB`. """ @@ -159,12 +159,12 @@ combinedKey = "escape/ctrl+[" combinedName = "normal" combinedDescription = "Enter normal mode" key = "{{key}}" -mode = "{{all_modes}}" +mode = "{{all_modes()}}" hideInPalette = true hideInDocs = false command = "master-key.enterNormal" when = "!findWidgetVisible" -prefixes = "{{all_prefixes}}" +prefixes = "{{all_prefixes()}}" [[bind]] default = "{{bind.modes}}" @@ -176,8 +176,8 @@ hideInDocs = true when = "suggestWidgetVisible && editorTextFocus && !findWidgetVisible" command = "runCommands" args.commands = ["hideSuggestWidget", "master-key.enterNormal"] -mode = "{{all_modes}}" -prefixes = "{{all_prefixes}}" +mode = "{{all_modes()}}" +prefixes = "{{all_prefixes()}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect [[bind]] @@ -188,8 +188,8 @@ foreach.key = ["{{keys(`.`}}"] foreach.modifier = ["shift+", ""] key = "{{modifier}}{{key}}" command = "master-key.ignore" -prefixes = "{{all_prefixes}}" -mode = ["normal", "selectedit"] +prefixes = "{{all_prefixes()}}" +mode = '{{all_modes_but(["normal", "selectedit"]}}' when = "editorTextFocus" hideInDocs = true hideInPalette = true @@ -327,7 +327,7 @@ command = "expandLineSelection" [[bind]] default = "{{bind.edit_motion_prim}}" key = "ctrl+d" -mode = ["normal", "insert"] +mode = '{{all_modes_but(["normal", "insert"]}}' name = "pg ↓" combinedName = "pg ↓/↑" combinedKey = "ctrl+d/ctrl+u" @@ -341,7 +341,7 @@ args.select = "{{mode == 'normal'}}" [[bind]] default = "{{bind.edit_motion_prim}}" key = "ctrl+u" -mode = ["normal", "insert"] +mode = '{{all_modes_but(["normal", "insert"]}}' name = "pg ↑" combinedName = "pg ↓/↑" description = "move up, relative to page size" @@ -547,7 +547,7 @@ combinedName = "→/← sel" description = "select *just* the character to the right" combinedDescription = "select *just* the character to the right" combinedKey = 'shift+\/\' -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' command = "runCommands" [[bind.args.commands]] @@ -563,7 +563,7 @@ key = 'shift+\' name = "← sel" combinedName = "→/← sel" description = "select *just* the character to the left" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' command = "runCommands" [[bind.args.commands]] @@ -637,7 +637,7 @@ combinedName = "count 0-9" combinedDescription = "Add digit 1-9 to count argument of a command" args.value = "{{num}}" finalKey = false -mode = ["!insert", "!capture"] +mode = '{{all_modes_except(["insert", "capture"])}}' hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions @@ -1505,14 +1505,14 @@ name = "insert" description = "Switch to insert mode (right before character)" command = "runCommands" args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] -mode = ["normal", "selectedit", "syminsert"] +mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' [[bind]] default = "{{bind.edit_action}}" key = "a" name = "append" description = "insert after cursor" -mode = ["normal", "selectedit", "syminsert"] +mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", @@ -1524,7 +1524,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "shift+i" name = "insert start" -mode = ["normal", "selectedit", "syminsert"] +mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ { command = "cursorMove", args = { to = "wrappedLineFirstNonWhitespaceCharacter", select = false } }, @@ -1535,7 +1535,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "shift+a" name = "insert end" -mode = ["normal", "selectedit", "syminsert"] +mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ { command = "cursorMove", args = { to = "wrappedLineEnd", select = false } }, @@ -1604,7 +1604,7 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+c" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' when = "master-key.count > 1" command = "runCommands" args.commands = [ @@ -1637,7 +1637,7 @@ command = "master-key.replaceChar" default = "{{bind.edit_action}}" key = "ctrl+i" name = "insert char" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' description = "insert a character in front of the cursor" command = "master-key.insertChar" @@ -1670,7 +1670,7 @@ args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] default = "{{bind.edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" -mode = ["normal", "insert"] +mode = '{{all_modes_but(["normal", "insert"]}}' name = "paste in" combinedName = "paste before/after/in" description = "Paste clipboard at location" @@ -1900,7 +1900,7 @@ command = "selection-utilities.decrementNumber" [[define.bind]] id = "edit_action_capitals" default = "{{bind.edit_action}}" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' [[bind]] default = "{{bind.edit_action_capitals}}" @@ -2106,7 +2106,7 @@ name = 'join' combinedName = "wrap/join lines" description = "Remove newline between current and next line" key = "space j" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' when = "!editorHasSelection" command = "runCommands" args.commands = ["{{command.selectLinesDown}}", 'editor.action.joinLines'] @@ -2116,7 +2116,7 @@ default = "{{bind.edit_action}}" combinedName = "wrap/join lines" name = 'join' description = "Remove newline between current and next line" -mode = ["normal", "selectedit"] +mode = '{{all_modes_but(["normal", "selectedit"]}}' key = "space j" command = "editor.action.joinLines" @@ -2407,8 +2407,8 @@ key = "shift+ctrl+;" name = "palette" finalKey = false hideInPalette = true -mode = "{{all_modes}}" -prefixes = "{{all_prefixes}}" +mode = "{{all_modes()}}" +prefixes = "{{all_prefixes()}}" description = """ show command suggestions within the context of the current mode and keybinding prefix (if any keys have already been typed) @@ -2930,12 +2930,12 @@ name = "del. cursors" description = "Delete all selections and return to normal" command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] -mode = ["selectedit", "normal"] +mode = '{{all_modes_but(["selectedit", "normal"]}}' [[bind]] default = "{{bind.edit_select_edit}}" key = "ctrl+'" -mode = ["insert", "selectedit", "normal"] +mode = '{{all_modes_but(["insert", "selectedit", "normal"]}}' name = "rm cursors" combinedName = "rm cursors" description = "Delete all selections and return to normal" From 84cfeb56974527e22d7a4f4b03b57b60ec4a5276 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 10 Sep 2025 00:00:31 -0400 Subject: [PATCH 44/79] mostly working pipeline for `bind` and `define` parsing Created using spr 1.3.6-beta.1 --- .vscode/launch.json | 4 +- .vscode/tasks.json | 36 ++++---- notes.md | 22 ++++- package.json | 5 -- src/extension/keybindings/index.ts | 85 +++---------------- src/rust/parsing/Cargo.lock | 1 + src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/src/bind.rs | 2 +- src/rust/parsing/src/error.rs | 6 +- src/rust/parsing/src/file.rs | 35 ++++---- .../test-workspace/my_bindings.mk.toml | 38 +++------ 11 files changed, 91 insertions(+), 144 deletions(-) diff --git a/.vscode/launch.json b/.vscode/launch.json index 0e650c30..b9073731 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -12,7 +12,9 @@ "args": [ "--extensionDevelopmentPath=${workspaceFolder}", "--profile", - "debug", + "master-key-debug", + "--install-extension", + "tamasfe.even-better-toml" ], "outFiles": [ "${workspaceFolder}/out/node/**/*.js" diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 13785e7c..42302fa6 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -25,6 +25,24 @@ } ] }, + { + "applyTo": "allDocuments", + "source": "tsc", + "fileLocation": "relative", + "pattern": [ + { + "regexp": "^\\[lint\\]\\s+([0-9]+):([0-9]+)\\s*([a-z]+)\\s*(.*)$", + "line": 1, + "column": 2, + "severity": 3, + "message": 4 + }, + { + "regexp": "^\\[lint\\]\\s(.*\\ts)\\s*$", + "file": 1, + } + ] + }, { "applyTo": "allDocuments", "base": "$esbuild", @@ -40,24 +58,6 @@ } } }, - { - "applyTo": "closedDocuments", - "source": "eslint", - "fileLocation": "absolute", - "pattern": [ - { - "regexp": "^\\[lint\\]\\s(.*)$", - "file": 1, - }, - { - "regexp": "^\\[lint\\]\\s+([0-9]+):([0-9]+)\\s+([a-z]+)\\s+(.*)$", - "line": 1, - "code": 2, - "severity": 3, - "message": 4 - } - ] - }, ], "isBackground": true, "label": "npm: watch:esbuild", diff --git a/notes.md b/notes.md index 738dd54b..ad6177b3 100644 --- a/notes.md +++ b/notes.md @@ -105,13 +105,31 @@ Integration test debugging: - [X] preparse all `{{}}` into AST - [X] evaluate expressions in command etc... - [X] foreach expansion within a KeyFile context + - [X] I'm running into some issues with Rhai, consider switching: + - it's large + - it has a number of frail dependencies (e.g. no longer maintained) + - I'm a *little* bit concerned by the overall judgement/attitude of the maintainer (seems okay with a dependency that is no longer maintained + to avoid "breakage") + - alternatives: + - mlua: looks nice and stable but no WASM support + - doesn't support WASM + - koto: a little less stable and with less backing + but has many features I want + - having slept on it, I don't think the tradeoffs for koto + are much better than Rhai. Rhai has seen more use and is a similar + scale of project (pet project of one person with some support + from other developers), while being less battle tested. + - starlark: backed by big tech this is definitely more reliable + but it is also large and ambitious and not intended for + small embedded-language applications + - conclusion: we stick with Rhai - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls - [X] implementation - [X] unit tests - [X] basic parsing - [X] define expansion for `bind.` and `command.` - - [ ] try it out from extension debugging - - [ ] write some integration tests + - [X] try it out from extension debugging + - [ ] write some type-script unit tests - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] re-organize the code into smaller units diff --git a/package.json b/package.json index a445187e..2a7c4283 100644 --- a/package.json +++ b/package.json @@ -23,11 +23,6 @@ "browser": "./out/browser/index.js", "contributes": { "commands": [ - { - "command": "master-key.test-rust", - "category": "Master Key", - "title": "Test Rust" - }, { "command": "master-key.activateBindings", "category": "Master Key", diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 61a204d0..3df38745 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -26,7 +26,7 @@ import JSONC from 'jsonc-simple-parser'; import TOML from 'smol-toml'; // run `mise build-rust` to create this auto generated source fileu -import initParsing, { parse_string } from '../../rust/parsing/lib'; +import initParsing, { parse_keybinding_bytes } from '../../rust/parsing/lib'; //////////////////////////////////////////////////////////////////////////////////////////// // Keybinding Generation @@ -642,16 +642,12 @@ async function loadPresets(allDirs: vscode.Uri[]) { let extensionPresetsDir: vscode.Uri; -async function validateKeybindings(file: vscode.Uri, fileString?: string) { +async function validateKeybindings(file: vscode.Uri, fileData?: Uint8Array) { if (file.toString().endsWith('.mk.toml')) { - if (fileString === undefined) { - const fileData = await vscode.workspace.fs.readFile(file); - // TODO: at some point we can probably circumvent the need to decode the file - // (since we can write the rust code to accept bytes instead of a string) - fileString = new TextDecoder('utf8').decode(fileData); + if (fileData === undefined) { + fileData = await vscode.workspace.fs.readFile(file); } - // TODO: read bytes directly in `parse_string` to avoid extra copies - const parsed = parse_string(fileString); + const parsed = parse_keybinding_bytes(fileData!); if (parsed.errors) { const diagnosticItems: vscode.Diagnostic[] = []; for (const error of parsed.errors) { @@ -676,7 +672,8 @@ async function validateKeybindings(file: vscode.Uri, fileString?: string) { ), ), message, - firstMessage ? vscode.DiagnosticSeverity.Error : + firstMessage ? + vscode.DiagnosticSeverity.Error : vscode.DiagnosticSeverity.Hint, ), ); @@ -704,8 +701,12 @@ export async function activate(context: vscode.ExtensionContext) { diagnostics = vscode.languages.createDiagnosticCollection('Master Key Bindings'); + const encoder = new TextEncoder(); vscode.workspace.onDidChangeTextDocument(async (e) => { - debounce(() => validateKeybindings(e.document.uri, e.document.getText()), 500)(); + debounce(() => { + const bytes = encoder.encode(e.document.getText()); + validateKeybindings(e.document.uri, bytes); + }, 1000)(); }); vscode.workspace.onDidSaveTextDocument(async (e) => { @@ -720,68 +721,6 @@ export async function activate(context: vscode.ExtensionContext) { const bits = await vscode.workspace.fs.readFile(filename); await initParsing(bits); - context.subscriptions.push( - vscode.commands.registerCommand('master-key.test-rust', () => { - const parsed = parse_string(` - [[bind]] - command = "do" - args = { a = "2", b = 3 } - key = "a" - when = "joe > 1" - mode = "normal" - priority = 1 - defaults = "foo.bar" - prefixes = "c" - finalKey = true - repeat = "2+c" - name = "foo" - description = "foo bar bin" - hideInPalette = false - hideInDocs = false - combinedName = "Up/down" - combinedKey = "A/B" - combinedDescription = "bla bla bla" - kind = "biz" - whenComputed = "f > 2" - `); - - if (parsed.file) { - const binding = parsed.file.bind[0]; - vscode.window.showInformationMessage(`Rust says: - command: ${binding.commands[0].command}, - args: ${JSON.stringify(binding.commands[0].args, null, 2)} - key: ${binding.key} - when: ${binding.when} - mode: ${binding.mode} - priority: ${binding.priority} - defaults: ${binding.defaults} - prefixes: ${binding.prefixes} - finalKey: ${binding.finalKey} - computedRepeat: ${binding.repeat} - name: ${binding.name} - description: ${binding.description} - hideInPalette: ${binding.hideInPalette} - hideInDocs: ${binding.hideInDocs} - combinedName: ${binding.combinedName} - combinedKey: ${binding.combinedKey} - combinedDescription: ${binding.combinedDescription} - kind: ${binding.kind} - `); - } else if (parsed.errors) { - let message = ''; - for (const item of parsed.errors[0].items) { - message += (item.message || '') + ' at ' + - (item.range ? `(${item.range.start}, ${item.range.end})` : '') + - '\n'; - } - vscode.window.showErrorMessage( - 'Parsing error: ' + message, - ); - } - }), - ); - - // TODO: add all user bindings /** * @userCommand activateBindings * @name Activate Keybindings diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 10877aed..5b3d4d68 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -352,6 +352,7 @@ version = "0.1.0" dependencies = [ "env_logger", "indexmap", + "instant", "js-sys", "lazy_static", "log", diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 8798b49f..f280fad4 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -26,6 +26,7 @@ thiserror = "2.0.12" toml = { version = "0.9.2", features = ["preserve_order"] } wasm-bindgen = "0.2.100" wasm-bindgen-test = "0.3.50" +instant = { version = "0.1.13", features = ["wasm-bindgen"] } [lib] crate-type = ["cdylib"] diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 4715f66f..498e47e4 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -417,7 +417,7 @@ impl Scope { })?); } - fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { + pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { x.clone().map_expressions(&mut |expr| { let ast = self.engine.compile_expression(expr.clone())?; self.asts.insert(expr.clone(), ast); diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index eedc4207..55c1ebb5 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -77,9 +77,9 @@ impl From for ErrorsWithContext { #[wasm_bindgen] impl ErrorWithContext { - pub fn report(&self, content: &str) -> ErrorReport { + pub fn report(&self, content: &[u8]) -> ErrorReport { let mut items = Vec::with_capacity(self.contexts.len() + 1); - let offsets: StringOffsets = StringOffsets::new(content); + let offsets: StringOffsets = StringOffsets::from_bytes(content); items.push(match &self.error { Error::TomlParsing(toml) => ErrorReportItem { message: Some(toml.message().into()), @@ -114,7 +114,7 @@ impl ErrorWithContext { #[wasm_bindgen] impl ErrorsWithContext { - pub fn report(&self, content: &str) -> Vec { + pub fn report(&self, content: &[u8]) -> Vec { return self.errors.iter().map(|e| e.report(content)).collect(); } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 9dd44aa5..7ae99b35 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,11 +1,8 @@ // top-level parsing of an entire file -use crate::bind::{Binding, BindingInput}; +use crate::bind::{Binding, BindingInput, Scope}; use crate::define::{Define, DefineInput}; -use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; -use crate::value::Value; +use crate::error::{self, ErrorContext, ErrorReport, ResultVec, flatten_errors}; -use js_sys::Math::exp; -use log::info; use serde::{Deserialize, Serialize}; use toml::Spanned; use wasm_bindgen::prelude::*; @@ -51,18 +48,24 @@ impl KeyFile { Ok(x) => x, }; + let mut scope = Scope::new(); + let _ = scope + .parse_asts(&bind_input) + .map_err(|mut es| errors.append(&mut es.errors)); + let bind: Vec<_> = bind_input .into_iter() .flat_map(|x| { let span = x.span().clone(); match x.into_inner().expand_foreach() { Ok(replicates) => { - // we resolve the foreach elements originating from a single item here, - // rather than expanding and flattening all errors. That's because we - // only want the first instance of an error at a given text span to show - // up in the final error output (e.g. if we have foreach.key = [1,2,3] - // we don't want an error about a missing required key to show up three - // times + // we resolve the foreach elements originating from a single item + // here, rather than expanding and flattening all errors across + // every iteration of the `foreach`. That's because we only want the + // first instance of an error at a given text span to show up in the + // final error output (e.g. if we have [[bind]] item with + // foreach.key = [1,2,3] we don't want an error about a missing + // required `key` field` to show up three times let items = replicates .into_iter() .map(Binding::new) @@ -99,21 +102,21 @@ pub struct KeyFileResult { } #[wasm_bindgen] -pub fn parse_string(file_content: &str) -> KeyFileResult { - return match parse_string_helper(file_content) { +pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { + return match parse_bytes_helper(&file_content) { Ok(result) => KeyFileResult { file: Some(result), errors: None, }, Err(err) => KeyFileResult { file: None, - errors: Some(err.errors.iter().map(|e| e.report(file_content)).collect()), + errors: Some(err.errors.iter().map(|e| e.report(&file_content)).collect()), }, }; } -fn parse_string_helper(file_content: &str) -> ResultVec { - let parsed = toml::from_str::(file_content)?; +fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { + let parsed = toml::from_slice::(file_content)?; return KeyFile::new(parsed); } diff --git a/src/test/integration/test-workspace/my_bindings.mk.toml b/src/test/integration/test-workspace/my_bindings.mk.toml index 3080950d..2b112070 100644 --- a/src/test/integration/test-workspace/my_bindings.mk.toml +++ b/src/test/integration/test-workspace/my_bindings.mk.toml @@ -1,14 +1,18 @@ + +[[define.bind]] +id = "my_defaults" +command = "bar" +key = "c" + [[bind]] -key = "a" -command = "foo" -args = { a = "2", b = 3 } +default = "{{bind.my_defaults}}" +args = { a = "2", b = 3, c = "{{x + 1}}" } when = "joe > 1" mode = "normal" priority = 1 -defaults = "foo.bar" prefixes = "c" finalKey = true -repeat = "2+c" +repeat = "{{2+c}}" name = "foo" description = "foo bar bin" hideInPalette = false @@ -17,25 +21,9 @@ combinedName = "foo/bar" combinedKey = "A/B" combinedDescription = "bla bla bla" kind = "biz" -whenComputed = "f > 2" [[bind]] -key = "b" -command = "bar" -args = { a = "2", b = 3 } -when = "joe > 1" -mode = "normal" -priority = 1 -defaults = "foo.bar" -prefixes = "c" -finalKey = true -repeat = "2+c" -name = "foo" -description = "foo bar bin" -hideInPalette = false -hideInDocs = false -combinedName = "foo/bar" -combinedKey = "A/B" -combinedDescription = "bla bla bla" -kind = "biz" -whenComputed = "f > 2" +foreach.key = ["{{0..9}}"] +key = "c {{key}}" +command = "foobar" +args.value = "{{key}}" From e42b15247e0e0fae365682639c2de66e5a10e71d Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 10 Sep 2025 15:33:53 -0400 Subject: [PATCH 45/79] unit tests: file parsing reports errors in open file Created using spr 1.3.6-beta.1 --- notes.md | 4 +- src/extension/keybindings/index.ts | 7 +-- .../test-workspace/my_bindings.mk.toml | 3 +- src/test/unit/change-mk-toml.test.ts | 61 +++++++++++++++++++ src/test/unit/command-do.test.ts | 3 +- src/test/unit/command-replay.test.ts | 3 +- src/test/unit/command-search.test.ts | 3 +- src/test/unit/utils.ts | 25 ++++++-- 8 files changed, 92 insertions(+), 17 deletions(-) create mode 100644 src/test/unit/change-mk-toml.test.ts diff --git a/notes.md b/notes.md index ad6177b3..3d28ef8c 100644 --- a/notes.md +++ b/notes.md @@ -123,13 +123,13 @@ Integration test debugging: but it is also large and ambitious and not intended for small embedded-language applications - conclusion: we stick with Rhai - - [ ] get `KeyFile` working with `bind`, `define` and runtime `command` calls + - [X] get `KeyFile` working with `bind`, `define` and runtime `command` calls - [X] implementation - [X] unit tests - [X] basic parsing - [X] define expansion for `bind.` and `command.` - [X] try it out from extension debugging - - [ ] write some type-script unit tests + - [X] write some type-script unit tests - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] re-organize the code into smaller units diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 3df38745..4ea94d2f 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -542,10 +542,8 @@ async function handleRequireExtensions(bindings_?: Bindings) { 'workbench.extensions.installExtension', item.label, ); - } catch (e) { + } catch (_) { vscode.window.showErrorMessage('Error installing extension: ' + item.label); - console.log('Error installing extension: ' + item.label); - console.dir(e); } } } @@ -704,7 +702,8 @@ export async function activate(context: vscode.ExtensionContext) { const encoder = new TextEncoder(); vscode.workspace.onDidChangeTextDocument(async (e) => { debounce(() => { - const bytes = encoder.encode(e.document.getText()); + const text = e.document.getText(); + const bytes = encoder.encode(text); validateKeybindings(e.document.uri, bytes); }, 1000)(); }); diff --git a/src/test/integration/test-workspace/my_bindings.mk.toml b/src/test/integration/test-workspace/my_bindings.mk.toml index 2b112070..ee902062 100644 --- a/src/test/integration/test-workspace/my_bindings.mk.toml +++ b/src/test/integration/test-workspace/my_bindings.mk.toml @@ -2,7 +2,6 @@ [[define.bind]] id = "my_defaults" command = "bar" -key = "c" [[bind]] default = "{{bind.my_defaults}}" @@ -23,7 +22,7 @@ combinedDescription = "bla bla bla" kind = "biz" [[bind]] -foreach.key = ["{{0..9}}"] +foreach.key = ["{{keys(`[0-9]`)}}"] key = "c {{key}}" command = "foobar" args.value = "{{key}}" diff --git a/src/test/unit/change-mk-toml.test.ts b/src/test/unit/change-mk-toml.test.ts new file mode 100644 index 00000000..03374f99 --- /dev/null +++ b/src/test/unit/change-mk-toml.test.ts @@ -0,0 +1,61 @@ +import * as vscode from 'vscode'; +import * as assert from 'assert'; +import { editorWithText } from './utils'; + +suite('*.mk.toml Linting', () => { + test('Good file has no linting', async function () { + this.timeout(5000); + const body = ` + [[bind]] + name = "default" + command = "foobar" + key = "a" + + [[bind]] + name = "run_merged" + key = "k" + command = "bizbaz" + `; + + const [_editor, fileUri] = await editorWithText(body, '.mk.toml'); + + const diags = vscode.languages.getDiagnostics(); + for (const [file, diag] of diags) { + if (file.path.endsWith('mk.toml')) { + assert.equal(diag.length, 0); + } + } + + await vscode.workspace.fs.delete(fileUri); + }); + + test('Bad file causes a lint error', async function () { + this.timeout(5000); + // NOTE: there is no `key` field + const body = ` + [[bind]] + name = "default" + command = "foobar" + + [[bind]] + name = "run_merged" + key = "k" + command = "bizbaz" + `; + + const [_editor, fileUri] = await editorWithText(body, '.mk.toml'); + + const diags = vscode.languages.getDiagnostics(); + + assert.notEqual(diags.length, 0); + for (const [file, diag] of diags) { + if (file.path.endsWith('mk.toml')) { + assert.notEqual(diag.length, 0); + const error = diag.find(d => d.message == 'requires `key` field\n'); + assert.notEqual(error, undefined); + } + } + + await vscode.workspace.fs.delete(fileUri); + }); +}); diff --git a/src/test/unit/command-do.test.ts b/src/test/unit/command-do.test.ts index 6ac2a3e3..1c1c177c 100644 --- a/src/test/unit/command-do.test.ts +++ b/src/test/unit/command-do.test.ts @@ -7,8 +7,9 @@ import { assertCursorMovesBy, cursorToStart, editorWithText } from './utils'; suite('Do command', () => { let editor: vscode.TextEditor; suiteSetup(async () => { + let _; // eslint-disable-next-line @stylistic/max-len - editor = await editorWithText(`Anim reprehenderit voluptate magna excepteur dolore aliqua minim labore est + [editor, _] = await editorWithText(`Anim reprehenderit voluptate magna excepteur dolore aliqua minim labore est consectetur ullamco ullamco aliqua ex. Pariatur officia nostrud pariatur ex dolor magna. Consequat cupidatat amet nostrud proident occaecat ex. Ex cillum duis anim dolor cupidatat non nostrud non et sint ullamco. diff --git a/src/test/unit/command-replay.test.ts b/src/test/unit/command-replay.test.ts index d0d3c2df..4d8dd123 100644 --- a/src/test/unit/command-replay.test.ts +++ b/src/test/unit/command-replay.test.ts @@ -35,7 +35,8 @@ async function stopRecording() { suite('Replay command', () => { let editor: vscode.TextEditor; setup(async () => { - editor = await editorWithText(`a b c d + let _; + [editor, _] = await editorWithText(`a b c d e f g h i j k l`); }); diff --git a/src/test/unit/command-search.test.ts b/src/test/unit/command-search.test.ts index 78696fb0..28db0a5c 100644 --- a/src/test/unit/command-search.test.ts +++ b/src/test/unit/command-search.test.ts @@ -7,8 +7,9 @@ import { assertCursorMovesBy, cursorToPos, cursorToStart, editorWithText } from suite('Search command', () => { let editor: vscode.TextEditor; setup(async () => { + let _; // eslint-disable-next-line @stylistic/max-len - editor = await editorWithText(`foobar bum POINT_A Officia voluptate ex point_a commodo esse laborum velit + [editor, _] = await editorWithText(`foobar bum POINT_A Officia voluptate ex point_a commodo esse laborum velit ipsum velit excepteur sunt cillum nulla adipisicing cupidatat. Laborum officia do mollit do labore elit occaecat cupidatat non POINT_B.`); }); diff --git a/src/test/unit/utils.ts b/src/test/unit/utils.ts index b234324c..6d735254 100644 --- a/src/test/unit/utils.ts +++ b/src/test/unit/utils.ts @@ -1,15 +1,28 @@ import * as vscode from 'vscode'; import * as assert from 'assert'; -export async function editorWithText(body: string) { +import * as path from 'path'; +import * as os from 'os'; + +export async function editorWithText( + body: string, + fileExt: string = '.txt', +): Promise<[vscode.TextEditor, vscode.Uri]> { await vscode.commands.executeCommand('explorer.newFile'); - const editor_ = vscode.window.activeTextEditor; - assert.notEqual(editor_, undefined); - const editor = editor_!; + const fileName = `test-file-${Date.now()}${fileExt}`; + const filePath = path.join(os.tmpdir(), fileName); + + // Convert the string path to a VS Code URI + const fileUri = vscode.Uri.file(filePath); + + const fileContent = Buffer.from(body, 'utf8'); + await vscode.workspace.fs.writeFile(fileUri, fileContent); + + const document = await vscode.workspace.openTextDocument(fileUri); + const editor = await vscode.window.showTextDocument(document); - await editor.edit(e => e.insert(new vscode.Position(0, 0), body)); - return editor; + return [editor, fileUri]; } export function cursorToStart(editor: vscode.TextEditor) { From 43901ca956927cd45dc784ab40578dd159b524e2 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 13 Sep 2025 18:42:24 -0400 Subject: [PATCH 46/79] wip refactoring/documentation Created using spr 1.3.6-beta.1 --- notes.md | 35 +- src/extension/expressions.ts | 33 - src/extension/keybindings/parsing.ts | 318 --- src/presets/larkin.toml | 1746 ++++++++--------- src/rust/parsing/src/bind.rs | 915 +++------ src/rust/parsing/src/bind/command.rs | 224 +++ src/rust/parsing/src/bind/foreach.rs | 99 +- src/rust/parsing/src/bind/validation.rs | 25 +- src/rust/parsing/src/define.rs | 223 ++- src/rust/parsing/src/expression.rs | 178 ++ .../parsing/src/{ => expression}/value.rs | 282 +-- src/rust/parsing/src/file.rs | 30 +- src/rust/parsing/src/lib.rs | 4 +- src/rust/parsing/src/util.rs | 4 +- 14 files changed, 2086 insertions(+), 2030 deletions(-) create mode 100644 src/rust/parsing/src/bind/command.rs create mode 100644 src/rust/parsing/src/expression.rs rename src/rust/parsing/src/{ => expression}/value.rs (90%) diff --git a/notes.md b/notes.md index 3d28ef8c..a7b90bea 100644 --- a/notes.md +++ b/notes.md @@ -133,16 +133,37 @@ Integration test debugging: - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [ ] re-organize the code into smaller units - - [ ] update documentation of `bind`, `define` and expressions + - [X] bind is way to big start by breaking that up + - [ ] organize order of definitions in files (e.g. join separate `impl` + segments) + - [X] `bind` + - [X] define + - [X] value + - [X] validation + - [X] foreach + - [ ] error + - [X] expression + - [ ] file + - [ ] lib + - [ ] util + - [X] replace IndexMap with BTreeMap + - [X] update documentation of `bind`, `define` and `expressions` - [ ] update documentation rendering pipeline - [ ] fix and test command queues implementation (avoid so much copying) - - [ ] replace IndexMap with BTreeMap + - [ ] error reporting is still a little finicky + - [ ] could probably make what is part of the same error more explicit + - [ ] reduce types of errors and tie error message string more explicitly + to name of enum variant - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` - - [ ] implement support for `all` functions: - - [ ] `{{all_prefixes()}}` - - [ ] `{{all_modes()}}` - - [ ] `{{all_modes_but(["not_me", "or_me"])}}` + - [ ] improve expression evaluation + - [ ] support expressions in `foreach` resolution + - [ ] allow for `var` evaluation in parse-time expressions + - [ ] move all bare variables in an expression to `code.` object + - [ ] implement support for `all` functions: + - [ ] `{{all_prefixes()}}` + - [ ] `{{all_modes()}}` + - [ ] `{{all_modes_but(["not_me", "or_me"])}}` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls @@ -179,6 +200,8 @@ Integration test debugging: whose span overlaps - [ ] convert any bind elements in this overlap into markdown table - [ ] serialization of bindings to settings.json + - [ ] create data types to generate warnings/hints for old/unused fields + - [ ] test this on the old version of larkin.toml - [ ] actually replace javascript behavior with rust functions - [ ] CI - [x] setup CI unit tests for rust diff --git a/src/extension/expressions.ts b/src/extension/expressions.ts index ac48ba51..13e6c09e 100644 --- a/src/extension/expressions.ts +++ b/src/extension/expressions.ts @@ -6,39 +6,6 @@ import { mapValues } from 'lodash'; const buildEvaled = new SafeExpression(); -/** - * @file expressions/index.md - * - * ## Expressions - * - * There are a number of places where you can use expressions when defining a keybinding. - * Any field that is evaluated as an expression includes the word `computed` in its name. - * The expressions are - * [AngularJS](https://www.w3schools.com/angular/angular_expressions.asp) expressions. When - * an expression is evaluated the following values are in scope: - * - * - Any field defined in the top-level [`define`](/bindings/define) field - * - Any value set by [`setFlag`](/commands/setFlag) - * - `editorHasSelection`: true if there is any selection, false otherwise - * - `editorHasMultipleSelections`: true if there are multiple selections, false otherwise - * - `firstSelectionOrWord`: the first selection, or the word under the first cursor if the - * selection is empty - * - `editorLangId`: the [language - * id](https://code.visualstudio.com/docs/languages/identifiers) of the current editor or - * the empty string if there is no current editor (or no language id for that editor) - * - `mode`: the current keybinding mode - * - `count`: The current count, as defined by - * [`master-key.updateCount`](/commands/updateCount) - * - `captured`: The text currently captured by the most recent call to - * [`master-key.restoreNamed`](/commands/restoreNamed) or - * [`master-key.captureKeys`](/commands/captureKeys). - * - `prefix`: The currently active [keybinding prefix](/commands/prefix) - * - `record`: a boolean flag used to indicate when keys are marked for recording - * - `commandHistory`: an array containing all previously run master key commands, up to the - * number configured by Master Key's "Command History Maximum" (defaults to 1024). - * Commands are stored from least recent (smallest index) to most recent (largest index). - */ - export function reifyStrings(obj: unknown, ev: (str: string) => unknown): unknown { if (Array.isArray(obj)) { return obj.map(x => reifyStrings(x, ev)); diff --git a/src/extension/keybindings/parsing.ts b/src/extension/keybindings/parsing.ts index dc82d547..2cc2a8b9 100644 --- a/src/extension/keybindings/parsing.ts +++ b/src/extension/keybindings/parsing.ts @@ -151,66 +151,11 @@ const bindingHeader = z. strict(); // type BindingHeader = z.infer; -/** - * @bindingField bind - * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` - * - * **Example** - * - * ```toml - * [[bind]] - * name = "left" - * key = "h" - * mode = "normal" - * command = "cursorLeft" - * ``` - * The `bind` element has two categories of fields: functional and documenting. - * - * ## Functional Fields - * - * The functional fields determine what the keybinding does. Required fields are marked with - * a `*`. - * - */ - const rawBindingCommand = z. object({ - /** - * @forBindingField bind - * - * - `command`*: A string denoting the command to execute. This is a command - * defined by VSCode or an extension thereof. - * See [finding commands](#finding-commands). This field has special - * behavior for the command `runCommands` - * (see [running multiple commands](#running-multiple-commands)). - */ command: z.string().optional(), // only optional before default expansion - /** - * @forBindingField bind - * - * - `args`: The arguments to directly pass to the `command`, these are static - * values. - */ args: z.any(), - /** - * @forBindingField bind - * - * - `computedArgs`: Like `args` except that each value is a string that is - * evaluated as an [expression](/expressions/index). - */ computedArgs: z.object({}).passthrough().optional(), - /** - * @forBindingField bind - * @order 5 - * - * - `whenComputed`: an [expression](/expressions/index) that, if evaluated to - * false, the command will not execute. Favor `when` clauses over `whenComputed`. - * The `whenComputed` field is distinct from the `when` clause because it uses the - * scope of expressions rather than when clause statements. Furthermore, even if - * the `whenComputed` is false, the binding is still considered to have triggered, - * and now downstream keybindings will be triggered. It is most useful in - * conjunction with `runCommands` or [`storeCommand`](/commands/storeCommand). - */ whenComputed: z.string().or(z.boolean()).default(true).optional(), }). strict(); @@ -396,146 +341,31 @@ export const vscodeBinding = z.object({ }); export const rawBindingItem = z.object({ - /** - * @forBindingField bind - * - * - `key`*: the - * [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that - * triggers `command`. - */ key: z.string().optional(), - /** - * @forBindingField bind - * - * - `when`: A [when - * clause](https://code.visualstudio.com/api/references/when-clause-contexts) - * context under which the binding will be active. Also see Master Key's - * [available contexts](#available-contexts) - */ when: z. union([z.string(), z.string().array()]). optional(). transform(parseWhen). pipe(parsedWhen.array()), - /** - * @forBindingField bind - * - * - `mode`: The mode during which the binding will be active. The default mode is - * used when this field is not specified (either directly or via the `defaults` - * field) - */ mode: z.union([z.string(), z.string().array()]).optional(), - /** - * @forBindingField bind - * - * - `priority`: The ordering of the keybinding relative to others; determines which - * bindings take precedence. Defaults to 0. - */ priority: z.number().default(0).optional(), - /** - * @forBindingField bind - * - * - `defaults`: the hierarchy of defaults applied to this binding, see - * [`default`](/bindings/default) for more details. - */ defaults: z.string().optional(), - /** - * @forBindingField bind - * - * - `foreach`: Allows parametric definition of multiple keybindings, see - * [`foreach` clauses](#foreach-clauses). - */ foreach: z.record(z.string(), z.array(z.string())).optional(), - /** - * @forBindingField bind - * - * - `prefixes`: (array of strings or the string - * {{all_prefixes}}). Determines one or more *unresolved* key - * sequences that can have occurred before typing this key. See - * [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. - * no prefix is allowed). This can be set to {{all_prefixes}}, - * if you wish to allow the key binding to work regardless of any unresolved key - * sequence that has been pressed (e.g. this is used for the "escape" key binding - * in Larkin). - */ prefixes: z. preprocess( x => (x === '{{all_prefixes}}' ? [] : x), bindingKey.or(z.string().length(0)).array(), ). optional(), - /** - * @forBindingField bind - * - * - `finalKey`: (boolean, default=true) Whether this key should clear any transient - * state associated with the pending keybinding prefix. See - * [`master-key.prefix`](/commands/prefix) for details. - */ finalKey: z.boolean().optional(), - /** - * @forBindingField bind - * - * - `computedRepeat`: This is an [expression](/expressions/index). It is expected - * to evaluate to the number of times to repeat the command. Defaults to zero: one - * repeat means the command is run twice. - * - `command` will be repeated the given - * number of times. - */ computedRepeat: z.number().min(0).or(z.string()).default(0).optional(), - /** - * @forBindingField bind - * @order 10 - * - * ## Documenting Fields - * - * The documenting fields determine how the keybinding is documented. They are all - * optional. - * - * - `name`: A very description for the command; this must fit in the visual - * documentation so it shouldn't be much longer than five characters for most - * keys. Favor unicode symbols such as → and ← over text. - */ name: z.string().optional(), - /** - * @forBindingField bind - * @order 10 - * - * - `description`: A longer description of what the command does. Shouldn't be much - * longer than a single sentence for most keys. Save more detailed descriptions - * for the literate comments. - */ description: z.string().optional(), - /** - * @forBindingField bind - * @order 10 - * - * - `hideInPalette/hideInDocs`: whether to show the keys in the popup suggestions - * and the documentation. These both default to false. - */ hideInPalette: z.boolean().default(false).optional(), hideInDocs: z.boolean().default(false).optional(), - /** - * @forBindingField bind - * @order 10 - * - * - `combinedName/combinedKey/combinedDescription`: in the suggestion palette and - * textual documentation, keys that have the same `combinedName` will be - * represented as single entry, using the `combinedKey` and `combinedDescription` - * instead of `key` and `description`. The `combinedKey` for a multi-key sequence - * should only include the suffix key. All but the first key's `combinedKey` and - * `combinedDescription` are ignored. - */ combinedName: z.string().optional().default(''), combinedKey: z.string().optional().default(''), combinedDescription: z.string().optional().default(''), - /** - * @forBindingField bind - * @order 10 - * - * - `kind`: The broad cagegory of commands this binding falls under. There should - * be no more than 4-5 of these. Each `kind` here should have a corresponding - * entry in the top-level `kind` array. - */ kind: z.string().optional(), }).merge(rawBindingCommand).strict(); export type RawBindingItem = z.output; @@ -561,89 +391,6 @@ export const doArgs = bindingCommand.array().refine( ); export type DoArgs = z.infer; -/** - * @forBindingField bind - * @order 20 - * - * ## Finding Commands - * - * You can find commands in a few ways: - * - * - Find command you want to use from the command palette, and click on the gear (`⚙︎`) - * symbol to copy the command string to your clipboard - * - Review the - * [list of built-in commands](https://code.visualstudio.com/api/references/commands/index) - * - Run the command `Preferences: Open Default Keyboard Shortcuts (JSON)` to get a list of - * built-in commands and extension commands already associated with a keybinding - * - * Furthermore, you can also use: - * - * - [Master Key Commands](/commands/index) - * - [Selection Utility Commands](https://haberdashpi.github.io/vscode-selection-utilities/) - * - * Selection Utilities is a complimentary extension used extensively by the `Larkin` preset. - * - * ## Running Multiple Commands - * - * When `command` is set to `runCommands`, you can run multiple commands with a signle key - * press. The`args.commands` list can be: - * - * - an array of strings listing the commands - * - an array of objects with `command`, `args` `computedWhen` and `computedArgs` fields, - * defined in the same way as the top-level `bind` fields of the same names are defined. - * You cannot have nested calls to `"runCommands"`. - * - an object with the field `defined` set to a command object defined under a - * [`define`](/bindings/define) field. - * - * ## Available `when` Contexts - * - * Each keybinding can make use of any context defined in VSCode across any extension. - * Master Key adds the follow contexts: - * - * - All variables available in [expression](/expressions/index), prefixed with - * `master-key.` - * - `master-key.keybindingPaletteBindingMode`: true when the suggestion palette accepts - * keybinding key presses, false it accepts a string to search the descriptions of said - * keybindings - * - `master-key.keybindingPaletteOpen`: true when the suggestion palette is open - * - * ## `foreach` Clauses - * - * The `foreach` clause of a keybinding can be used to generate many bindings from one - * entry. Each field under `foreach` is looped through exhaustively. On each iteration, any - * string values that contain {{[var]}} where `[var]` is a `foreach` - * field, is replaced with that fields value for the given iteration. For example, the - * following defines 9 bindings: - * - * ::: v-pre - * ```toml - * [[bind]] - * foreach.a = [1,2,3] - * foreach.b = [1,2,3] - * key = "ctrl+; {{a}} {{b}}" - * command = "type" - * args.text = "{{a-b}}" - * ``` - * ::: - * - * Furthermore, if the value {{key: [regex]}} is included in a `foreach` - * field, it is expanded to all keybindings that match the given regular expression. For - * example, the following definition is used in `Larkin` to allow the numeric keys to be - * used as count prefix for motions. - * - * ::: v-pre - * ```toml - * [[bind]] - * foreach.num = ['{{key: [0-9]}}'] - * name = "count {{num}}" - * key = "{{num}}" - * command = "master-key.updateCount" - * description = "Add digit {{num}} to the count argument of a command" - * args.value = "{{num}}" - * # etc... - * ``` - * ::: - */ // TODO: the errors are not very informative if we transform the result so early in this // way; we need to keep this as close as possible to the form in the raw file @@ -678,75 +425,10 @@ export const bindingItem = z. strict(); export type BindingItem = z.output; -/** - * @bindingField default - * @description array that defines structured defaults that apply to keybinding subsets - * - * The `default` field describes a series of hierarchical defaults according to a - * period-delimited set of identifiers. - * - * **Example** - * - * ```toml - * [[default]] - * id = "motion" - * default.mode = "normal" - * - * [[default]] - * id = "motion.cursor" - * command = "cursorMove" - * - * [[bind]] - * name = "lines" - * description = "expand selection to full-line selections" - * key = "shift+l" - * command = "expandLineSelection" - * defaults = "motion" - * # mode = "normal" (because of the "motion" defaults) - * - * [[bind]] - * key = "l" - * name = "left" - * defaults = "motion.cursor" - * # mode = "normal" (because of the "motion" defaults) - * # command = "cursorMove" (because of the "motion.cursor" defaults) - * args.to = "left" - * ``` - * - * When you specify the defaults of a keybinding it draws not only from the exact id, but - * also any of its period-delimited prefixes. Prefixes match when the same set of - * identifiers in the same order occurs up until the end of the prefix: substrings are not - * matched. For example `foo.bar.baz` matches `foo.bar` and `foo` but it does not match - * `foo.ba`. In the above example, `motion.cursor` matches both `motion` and `motion.cursor` - * path definitions. - * - * The following fields are available. - * - */ export const bindingDefault = z.object({ - /** - * @forBindingField default - * - * - `id` is a period-delimited set of identifiers that describe this default; each - * identifier can include letters, numbers as well as `_` and `-`. - */ id: z.string().regex(/(^$|[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*)/), - /** - * @forBindingField default - * - * - `default`: contains all of the same fields as [`bind`](/bindings/bind), - * but they are all optional here. These are propagated to any keybindings - * associated with this default. - */ default: rawBindingItem.partial().optional(), - /** - * @forBindingField default - * - * - `appendWhen`: this when clause is appended to the when clause of all associated - * keybindings using `(when) && (appendWhen)`, and must therefore be true for any - * associated keybindings to trigger. - */ appendWhen: z. string(). optional(). diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 3bd5a0b8..6e7db669 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -26,7 +26,7 @@ #- NOTE: this file is used to generate both keybindings and to generate a markdown file that documents the bindings. When comments are prefixed with a `-` they are ignored in the final markdown output. All other comments will become part of the markdown output. Any [[bind]] entries unbroken by normal, markdown-displayed comments will show up in a table in the markdown output. Make sure that the normal comments do not break up TOML data in a way that means it is invalid TOML. [header] -name = "Larkin" +doc.name = "Larkin" version = "2.0" requiredExtensions = [ @@ -42,17 +42,17 @@ requiredExtensions = [ ] [[mode]] -name = "insert" +doc.name = "insert" recordEdits = true [[mode]] -name = "normal" +doc.name = "normal" default = true highlight = "Highlight" cursorShape = "Block" [[mode]] -name = "selectedit" +doc.name = "selectedit" highlight = "Highlight" cursorShape = "BlockOutline" @@ -60,20 +60,20 @@ cursorShape = "BlockOutline" select = false [[kind]] -name = "motion" -description = "These commands move the cursor and/or selections." +doc.name = "motion" +doc.description = "These commands move the cursor and/or selections." [[kind]] -name = "action" -description = """ +doc.name = "action" +doc.description = """ Actions do something with the selected text (e.g. delete it). Unless otherwise noted, in the absence of a selection, an action will modify an entire line, and a count argument indicates the number of lines (e.g. 3d deletes this line and the next 3 lines). """ [[kind]] -name = "util" -description = """ +doc.name = "util" +doc.description = """ Assorted other commands that aren't motions or actions """ @@ -98,7 +98,7 @@ args.commands = [ [[define.bind]] id = "modes" -kind = "util" +doc.kind = "util" # ## Getting Help @@ -111,30 +111,30 @@ kind = "util" [[bind]] default = "{{bind.util}}" key = "shift+;" -name = "suggest" +doc.name = "suggest" finalKey = false -hideInPalette = true +doc.hideInPalette = true prefixes = "{{all_prefixes()}}" mode = '{{all_modes_but(["capture", "insert"]}}' -description = """ +doc.description = """ show command suggestions within the context of the current mode and keybinding prefix (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that start with `TAB`. """ command = "master-key.commandSuggestions" [[bind]] key = "tab /" -name = "text docs" +doc.name = "text docs" priority = -1 mode = "normal" -description = "Show text documentation for keybindings" +doc.description = "Show text documentation for keybindings" command = "master-key.showTextDoc" [[bind]] key = "tab shift+/" -name = "visual doc" +doc.name = "visual doc" priority = -1 mode = "normal" -description = "Show visual documentation for keybindings" +doc.description = "Show visual documentation for keybindings" command = "master-key.showVisualDoc" # The visual keybinding documentation is modified by the following command: @@ -152,27 +152,27 @@ command = "master-key.showVisualDoc" [[bind]] default = "{{bind.modes}}" -name = "normal" -description = "Enter normal mode" +doc.name = "normal" +doc.description = "Enter normal mode" foreach.key = ["escape", "ctrl+["] -combinedKey = "escape/ctrl+[" -combinedName = "normal" -combinedDescription = "Enter normal mode" +doc.combinedKey = "escape/ctrl+[" +doc.combinedName = "normal" +doc.combinedDescription = "Enter normal mode" key = "{{key}}" mode = "{{all_modes()}}" -hideInPalette = true -hideInDocs = false +doc.hideInPalette = true +doc.hideInDocs = false command = "master-key.enterNormal" when = "!findWidgetVisible" prefixes = "{{all_prefixes()}}" [[bind]] default = "{{bind.modes}}" -name = "normal" +doc.name = "normal" foreach.key = ["escape", "ctrl+["] key = "{{key}}" -hideInPalette = true -hideInDocs = true +doc.hideInPalette = true +doc.hideInDocs = true when = "suggestWidgetVisible && editorTextFocus && !findWidgetVisible" command = "runCommands" args.commands = ["hideSuggestWidget", "master-key.enterNormal"] @@ -182,8 +182,8 @@ prefixes = "{{all_prefixes()}}" #- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect [[bind]] default = "{{bind.modes}}" -name = "ignore" -description = "this key does nothing" +doc.name = "ignore" +doc.description = "this key does nothing" foreach.key = ["{{keys(`.`}}"] foreach.modifier = ["shift+", ""] key = "{{modifier}}{{key}}" @@ -191,8 +191,8 @@ command = "master-key.ignore" prefixes = "{{all_prefixes()}}" mode = '{{all_modes_but(["normal", "selectedit"]}}' when = "editorTextFocus" -hideInDocs = true -hideInPalette = true +doc.hideInDocs = true +doc.hideInPalette = true priority = -10 [[define.bind]] @@ -203,7 +203,7 @@ mode = "normal" [[define.bind]] id = "edit_count" default = "{{bind.edit}}" -kind = "count" +doc.kind = "count" # ## Basic motions @@ -214,7 +214,7 @@ kind = "count" [[define.bind]] id = "edit_motion" default = "{{bind.edit}}" -kind = "motion" +doc.kind = "motion" tags = ["motion"] [[define.bind]] @@ -227,58 +227,58 @@ args.select = "{{editorHasSelection || var.select}}" [[bind]] default = "{{bind.edit_motion_prim}}" key = "h" -name = "←" -combinedName = "←/→" -combinedKey = "h/l" -combinedDescription = "move left/right" -description = "move left" +doc.name = "←" +doc.combinedName = "←/→" +doc.combinedKey = "h/l" +doc.combinedDescription = "move left/right" +doc.description = "move left" args.to = "left" mode = "normal" [[bind]] default = "{{bind.edit_motion_prim}}" key = "l" -combinedName = "←/→" -name = "→" -description = "move right" +doc.combinedName = "←/→" +doc.name = "→" +doc.description = "move right" args.to = "right" [[bind]] default = "{{bind.edit_motion_prim}}" key = "j" -name = "↓" -combinedName = "↓/↑" -combinedKey = "j/k" -combinedDescription = "move down/up" -description = "move down" +doc.name = "↓" +doc.combinedName = "↓/↑" +doc.combinedKey = "j/k" +doc.combinedDescription = "move down/up" +doc.description = "move down" args.to = "down" args.by = "wrappedLine" [[bind]] default = "{{bind.edit_motion_prim}}" key = "k" -name = "↑" -description = "move up" -combinedName = "↓/↑" +doc.name = "↑" +doc.description = "move up" +doc.combinedName = "↓/↑" args.to = "up" args.by = "wrappedLine" [[bind]] default = "{{bind.edit_motion_prim}}" key = "shift+h" -name = "start" -description = "start of line (alternates between first non-white and first)" -combinedName = "start/end" -combinedKey = "shift+h/shift+l" -combinedDescription = "move to start/end of line" +doc.name = "start" +doc.description = "start of line (alternates between first non-white and first)" +doc.combinedName = "start/end" +doc.combinedKey = "shift+h/shift+l" +doc.combinedDescription = "move to start/end of line" command = "cursorHomeSelect" [[bind]] # we don't use prim because we don't want the defaults default = "{{bind.edit_motion}}" key = "shift+l" -name = "end" -combinedName = "start/end" -description = "end of line" +doc.name = "end" +doc.combinedName = "start/end" +doc.description = "end of line" command = "cursorMove" args.to = "wrappedLineEnd" args.select = true @@ -286,11 +286,11 @@ args.select = true [[bind]] default = "{{bind.edit_motion_prim}}" key = "shift+k" -name = "sel ↑" -combinedName = "sel ↑/↓" -combinedDescription = "select lines up/down" -combinedKey = "shift+k/shift+j" -description = "select lines upwards" +doc.name = "sel ↑" +doc.combinedName = "sel ↑/↓" +doc.combinedDescription = "select lines up/down" +doc.combinedKey = "shift+k/shift+j" +doc.description = "select lines upwards" command = "runCommands" [[bind.args.commands]] @@ -309,9 +309,9 @@ command = "selection-utilities.exchangeAnchorActive" [[bind]] default = "{{bind.edit_motion_prim}}" key = "shift+j" -name = "sel ↓" -combinedName = "sel ↑/↓" -description = "select lines downwards" +doc.name = "sel ↓" +doc.combinedName = "sel ↑/↓" +doc.description = "select lines downwards" command = "runCommands" [[bind.args.commands]] @@ -328,11 +328,11 @@ command = "expandLineSelection" default = "{{bind.edit_motion_prim}}" key = "ctrl+d" mode = '{{all_modes_but(["normal", "insert"]}}' -name = "pg ↓" -combinedName = "pg ↓/↑" -combinedKey = "ctrl+d/ctrl+u" -combinedDescription = "move down/up, relative to page size" -description = "move down, relative to page size" +doc.name = "pg ↓" +doc.combinedName = "pg ↓/↑" +doc.combinedKey = "ctrl+d/ctrl+u" +doc.combinedDescription = "move down/up, relative to page size" +doc.description = "move down, relative to page size" command = "selection-utilities.activePageMove" args.dir = "down" args.count = "{{(count || 1)/3}}" @@ -342,9 +342,9 @@ args.select = "{{mode == 'normal'}}" default = "{{bind.edit_motion_prim}}" key = "ctrl+u" mode = '{{all_modes_but(["normal", "insert"]}}' -name = "pg ↑" -combinedName = "pg ↓/↑" -description = "move up, relative to page size" +doc.name = "pg ↑" +doc.combinedName = "pg ↓/↑" +doc.description = "move up, relative to page size" command = "selection-utilities.activePageMove" args.dir = "up" args.count = "{{(count || 1)/3}}" @@ -353,8 +353,8 @@ args.select = "{{mode == 'normal'}}" [[bind]] default = "{{bind.edit_motion_prim}}" key = "shift+x" -name = "exapand" -description = "expand selections to full lines" +doc.name = "exapand" +doc.description = "expand selections to full lines" command = "expandLineSelection" repeat = "{{count}}" @@ -367,48 +367,48 @@ args.select = true [[bind]] default = "{{bind.edit_motion_obj}}" key = "w" -name = "subwrd →" -description = "next subword (camel/snake case)" -combinedName = "subwrd ←/→" -combinedDescription = "next/prev subword (camel/snake case)" -combinedKey = "w/b" +doc.name = "subwrd →" +doc.description = "next subword (camel/snake case)" +doc.combinedName = "subwrd ←/→" +doc.combinedDescription = "next/prev subword (camel/snake case)" +doc.combinedKey = "w/b" args.unit = "subword" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "b" -name = "subwrd ←" -description = "previous subword (camel/snake case)" -combinedName = "subwrd ←/→" +doc.name = "subwrd ←" +doc.description = "previous subword (camel/snake case)" +doc.combinedName = "subwrd ←/→" args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+w" -name = "word →" -description = "next word" -combinedName = "word ←/→" -combinedDescription = "next/prev word" -combinedKey = "shift+w/b" +doc.name = "word →" +doc.description = "next word" +doc.combinedName = "word ←/→" +doc.combinedDescription = "next/prev word" +doc.combinedKey = "shift+w/b" args.unit = "word" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+b" -name = "word ←" -combinedName = "word ←/→" -description = "previous word" +doc.name = "word ←" +doc.combinedName = "word ←/→" +doc.description = "previous word" args.unit = "word" args.value = "{{-count || -1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "e" -name = "subwrd end" -description = "next subword (camel/snake case) end" +doc.name = "subwrd end" +doc.description = "next subword (camel/snake case) end" args.unit = "subword" args.boundary = "end" args.value = "{{count || 1}}" @@ -416,8 +416,8 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+e" -name = "word end" -description = "next word end" +doc.name = "word end" +doc.description = "next word end" args.unit = "word" args.boundary = "end" args.value = "{{count || 1}}" @@ -425,52 +425,52 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+]" -name = "parag. →" -description = "next paragraph" -combinedName = "paragraph →/←" -combinedDescription = "next/previous paragraph" -combinedKey = "shift+]/[" +doc.name = "parag. →" +doc.description = "next paragraph" +doc.combinedName = "paragraph →/←" +doc.combinedDescription = "next/previous paragraph" +doc.combinedKey = "shift+]/[" args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+[" -name = "parag. ←" -combinedName = "paragraph →/←" -description = "previous paragraph" +doc.name = "parag. ←" +doc.combinedName = "paragraph →/←" +doc.description = "previous paragraph" args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+0" -name = "subsec →" -description = "next subsection" -combinedName = "subsec →/←" -combinedDescription = "next/previous subsection" -combinedKey = "shift+0/9" +doc.name = "subsec →" +doc.description = "next subsection" +doc.combinedName = "subsec →/←" +doc.combinedDescription = "next/previous subsection" +doc.combinedKey = "shift+0/9" args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+9" -name = "subsec ←" -description = "previous subsection" -combinedName = "subsec →/←" +doc.name = "subsec ←" +doc.description = "previous subsection" +doc.combinedName = "subsec →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_prim}}" key = "v" -name = "shrink selection" -combinedName = "shrink/hold selection" -combinedDescription = """ +doc.name = "shrink selection" +doc.combinedName = "shrink/hold selection" +doc.combinedDescription = """ reduce selections to zero length / make all commands extend the selection """ -description = """ +doc.description = """ reduce all selections to length zero """ command = "runCommands" @@ -482,23 +482,23 @@ args.commands = [ [[bind]] default = "{{bind.edit_motion}}" key = "shift+v" -name = "hold selection" -combinedName = "shrink/hold selection" -description = """ +doc.name = "hold selection" +doc.combinedName = "shrink/hold selection" +doc.description = """ all motions extend the selection """ command = "master-key.setFlag" -args.name = "var.select" +args.doc.name = "var.select" args.value = true [[bind]] default = "{{bind.edit_action}}" -name = "open, act →" -description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" +doc.name = "open, act →" +doc.description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" key = "o" -combinedName = "open below/above, act →/←" -combinedKey = "o/shift+o" -combinedDescription = """ +doc.combinedName = "open below/above, act →/←" +doc.combinedKey = "o/shift+o" +doc.combinedDescription = """ without selection: open a line below/above current line and enter insert, with selection: move cursor to end/start of selection """ @@ -509,15 +509,15 @@ args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] [[bind]] default = "{{bind.edit_action}}" key = "o" -combinedName = "open below/above, act →/←" +doc.combinedName = "open below/above, act →/←" when = "editorHasSelection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_action}}" -name = "open blw, act ←" -combinedName = "open below/above, act →/←" -description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" +doc.name = "open blw, act ←" +doc.combinedName = "open below/above, act →/←" +doc.description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" key = "shift+o" when = "!editorHasSelection" command = "runCommands" @@ -525,9 +525,9 @@ args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] default = "{{bind.edit_action}}" -name = "open blw, act ←" -combinedName = "open below/above, act →/←" -description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" +doc.name = "open blw, act ←" +doc.combinedName = "open below/above, act →/←" +doc.description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" key = "shift+o" when = "editorHasSelection" command = "selection-utilities.activeAtStart" @@ -535,18 +535,18 @@ command = "selection-utilities.activeAtStart" [[bind]] default = "{{bind.edit_motion}}" key = "shift+5" -name = "to bracket" -description = "Move to matching bracket" +doc.name = "to bracket" +doc.description = "Move to matching bracket" command = "editor.action.jumpToBracket" [[bind]] default = "{{bind.edit_motion_prim}}" key = '\' -name = "→ sel" -combinedName = "→/← sel" -description = "select *just* the character to the right" -combinedDescription = "select *just* the character to the right" -combinedKey = 'shift+\/\' +doc.name = "→ sel" +doc.combinedName = "→/← sel" +doc.description = "select *just* the character to the right" +doc.combinedDescription = "select *just* the character to the right" +doc.combinedKey = 'shift+\/\' mode = '{{all_modes_but(["normal", "selectedit"]}}' command = "runCommands" @@ -560,9 +560,9 @@ args = { to = "right", select = true, value = "{{count}}" } [[bind]] default = "{{bind.edit_motion_prim}}" key = 'shift+\' -name = "← sel" -combinedName = "→/← sel" -description = "select *just* the character to the left" +doc.name = "← sel" +doc.combinedName = "→/← sel" +doc.description = "select *just* the character to the left" mode = '{{all_modes_but(["normal", "selectedit"]}}' command = "runCommands" @@ -576,25 +576,25 @@ args = { to = "left", select = true, value = "{{count}}" } [[bind]] default = "{{bind.edit_motion_obj}}" key = "shift+4" -name = "all" -description = "Select entire document" +doc.name = "all" +doc.description = "Select entire document" command = "editor.action.selectAll" [[bind]] default = "{{bind.edit_motion}}" key = "shift+r" -name = "trim wht" -description = "trim external whitespace" +doc.name = "trim wht" +doc.description = "trim external whitespace" command = "selection-utilities.trimSelectionWhitespace" [[bind]] default = "{{bind.edit_motion_obj}}" -name = "→ num." -description = "Move to next number" +doc.name = "→ num." +doc.description = "Move to next number" key = "shift+3" -combinedName = "→/← num." -combinedDescription = "Move to next/prev number" -combinedKey = "shift+3/2" +doc.combinedName = "→/← num." +doc.combinedDescription = "Move to next/prev number" +doc.combinedKey = "shift+3/2" args.unit = "number" args.selectWhole = true args.boundary = "both" @@ -602,10 +602,10 @@ args.value = "{{(count || 1)}}" [[bind]] default = "{{bind.edit_motion_obj}}" -name = "← num." -description = "Move to next number" +doc.name = "← num." +doc.description = "Move to next number" key = "shift+2" -combinedName = "→/← num." +doc.combinedName = "→/← num." args.unit = "number" args.selectWhole = true args.boundary = "both" @@ -613,8 +613,8 @@ args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion}}" -name = 'narrow to subword' -description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" +doc.name = 'narrow to subword' +doc.description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" key = "z" command = "selection-utilities.narrowTo" args.unit = "subident" @@ -628,25 +628,25 @@ args.boundary = "both" [[bind]] foreach.num = ['{{keys(`[0-9]`)}}'] -name = "count {{num}}" +doc.name = "count {{num}}" key = "{{num}}" command = "master-key.updateCount" -description = "Add digit {{num}} to the count argument of a command" -combinedKey = "0-9" -combinedName = "count 0-9" -combinedDescription = "Add digit 1-9 to count argument of a command" +doc.description = "Add digit {{num}} to the count argument of a command" +doc.combinedKey = "0-9" +doc.combinedName = "count 0-9" +doc.combinedDescription = "Add digit 1-9 to count argument of a command" args.value = "{{num}}" finalKey = false mode = '{{all_modes_except(["insert", "capture"])}}' -hideInDocs = true +doc.hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions [[bind]] default = "{{bind.edit_motion}}" key = ";" -name = "repeat motion" -description = """ +doc.name = "repeat motion" +doc.description = """ Repeat the last motion command. Motions usually move the cursor or change the selection. """ repeat = "{{count}}" @@ -659,8 +659,8 @@ commandHistory[index].name != 'shrink selection' [[bind]] default = "{{bind.edit_motion}}" -name = "repeat subject" -description = """ +doc.name = "repeat subject" +doc.description = """ Repeat the subject: a motion command that occurred right before an action. For instance `w` followed by `d` selects a word and deletes it. The `w` command would be the last subject until some new action is run after `d`. See also `.` which repeats the last action. @@ -676,53 +676,53 @@ commandHistory[index+1].tags.contains("history")) [[bind]] default = "{{bind.edit_motion}}" -name = "cursor undo" +doc.name = "cursor undo" key = "-" -combinedName = "cursor undo/redo" -combinedKey = "-/shift+-" +doc.combinedName = "cursor undo/redo" +doc.combinedKey = "-/shift+-" command = "cursorUndo" [[bind]] default = "{{bind.edit_motion}}" -name = "cursor redo" -combinedName = "cursor undo/redo" +doc.name = "cursor redo" +doc.combinedName = "cursor undo/redo" key = "shift+-" command = "cursorRedo" [[bind]] default = "{{bind.edit_motion}}" -name = "nav ←" -description = "Go back in navigation history (e.g. goto definition)" -combinedName = "nav ←/→" -combinedKey = "n/shift+n" -combinedDescription = "Go back/forward in navigation history" +doc.name = "nav ←" +doc.description = "Go back in navigation history (e.g. goto definition)" +doc.combinedName = "nav ←/→" +doc.combinedKey = "n/shift+n" +doc.combinedDescription = "Go back/forward in navigation history" key = "g n" command = "workbench.action.navigateBackInNavigationLocations" [[bind]] default = "{{bind.edit_motion}}" -name = "nav →" -combinedName = "nav ←/→" -description = "Go forward in navigation history (e.g. goto definition)" +doc.name = "nav →" +doc.combinedName = "nav ←/→" +doc.description = "Go forward in navigation history (e.g. goto definition)" key = "g shift+n" command = "workbench.action.navigateForwardInNavigationLocations" [[bind]] default = "{{bind.edit_motion}}" -name = "edit hist ←" -description = "Go back in edit history" +doc.name = "edit hist ←" +doc.description = "Go back in edit history" key = "g -" -combinedName = "edit ←/→" -combinedKey = "-/shift+-" -combinedDescription = "Go back/forward in edit history" +doc.combinedName = "edit ←/→" +doc.combinedKey = "-/shift+-" +doc.combinedDescription = "Go back/forward in edit history" command = "workbench.action.navigateBackInEditLocations" [[bind]] default = "{{bind.edit_motion}}" -name = "edit hist →" -description = "Go forward in edit history)" +doc.name = "edit hist →" +doc.description = "Go forward in edit history)" key = "g shift+-" -combinedName = "edit ←/→" +doc.combinedName = "edit ←/→" command = "workbench.action.navigateForwardInEditLocations" # ## Search Motions @@ -743,20 +743,20 @@ args.wrapAround = true [[bind]] default = "{{bind.edit_motion_search}}" key = "/" -name = "search →" -description = "search forwards" -combinedName = "search → (←)" -combinedDescription = "search forwards (backwards)" -combinedKey = "/ (shift+/)" +doc.name = "search →" +doc.description = "search forwards" +doc.combinedName = "search → (←)" +doc.combinedDescription = "search forwards (backwards)" +doc.combinedKey = "/ (shift+/)" args.offset = "start" args.register = "search" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+/" -name = "search ←" -description = "search backwards" -combinedName = "search → (←)" +doc.name = "search ←" +doc.description = "search backwards" +doc.combinedName = "search → (←)" args.offset = "start" args.register = "search" args.backwards = true @@ -764,8 +764,8 @@ args.backwards = true [[bind]] default = "{{bind.edit_motion_search}}" key = "n" -name = "→ search" -description = "Go to the next match of the search query" +doc.name = "→ search" +doc.description = "Go to the next match of the search query" command = "master-key.nextMatch" args.register = "search" args.repeat = "{{(count || 1)-1}}" @@ -773,8 +773,8 @@ args.repeat = "{{(count || 1)-1}}" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+n" -name = "← search" -description = "Go to the previous match of the search query" +doc.name = "← search" +doc.description = "Go to the previous match of the search query" command = "master-key.previousMatch" args.register = "search" args.repeat = "{{(count || 1)-1}}" @@ -782,11 +782,11 @@ args.repeat = "{{(count || 1)-1}}" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+8" -name = "match →" -description = "Next match to object under cursor" -combinedName = "match →/←" -combinedDescription = "Next/previous match to object under cursor" -combinedKey = "shift+8/7" +doc.name = "match →" +doc.description = "Next match to object under cursor" +doc.combinedName = "match →/←" +doc.combinedDescription = "Next/previous match to object under cursor" +doc.combinedKey = "shift+8/7" args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" @@ -794,9 +794,9 @@ args.register = "search" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+7" -name = "match ←" -description = "Previous match to object under cursor" -combinedName = "match →/←" +doc.name = "match ←" +doc.description = "Previous match to object under cursor" +doc.combinedName = "match →/←" args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" @@ -805,11 +805,11 @@ args.backwards = true [[bind]] default = "{{bind.edit_motion_search}}" key = "f" -name = "find char" -description = "Find the next char (include char in selection)" -combinedName = "find char (back)" -combinedDescription = "Find the next (previous) char (include char in selection)" -combinedKey = "f (shift+f)" +doc.name = "find char" +doc.description = "Find the next char (include char in selection)" +doc.combinedName = "find char (back)" +doc.combinedDescription = "Find the next (previous) char (include char in selection)" +doc.combinedKey = "f (shift+f)" args.acceptAfter = 1 args.skip = "{{count-1}}" args.offset = "inclusive" @@ -817,9 +817,9 @@ args.offset = "inclusive" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+f" -name = "find char back" -description = "Find the previous char (include char in selection)" -combinedName = "find char (back)" +doc.name = "find char back" +doc.description = "Find the previous char (include char in selection)" +doc.combinedName = "find char (back)" args.acceptAfter = 1 args.offset = "inclusive" args.backwards = true @@ -828,11 +828,11 @@ args.skip = "{{count-1}}" [[bind]] default = "{{bind.edit_motion_search}}" key = "t" -name = "to char" -description = "Find the next char (exclude char in selection)" -combinedName = "to char (back)" -combinedKey = "t (shift+t)" -combinedDescription = "Find the next/previous char (exclude char in selection)" +doc.name = "to char" +doc.description = "Find the next char (exclude char in selection)" +doc.combinedName = "to char (back)" +doc.combinedKey = "t (shift+t)" +doc.combinedDescription = "Find the next/previous char (exclude char in selection)" args.acceptAfter = 1 args.offset = "start" args.skip = "{{count-1}}" @@ -840,9 +840,9 @@ args.skip = "{{count-1}}" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+t" -name = "to char back" -description = "Find the previous char (exclude char in selection)" -combinedName = "to char (back)" +doc.name = "to char back" +doc.description = "Find the previous char (exclude char in selection)" +doc.combinedName = "to char (back)" args.acceptAfter = 1 args.offset = "end" args.backwards = true @@ -851,11 +851,11 @@ args.skip = "{{count-1}}" [[bind]] default = "{{bind.edit_motion_search}}" key = "s" -name = "find char pair" -description = "To next character pair" -combinedName = "char pair →/←" -combinedDescription = "To next character pair" -combinedKey = "s/shift+s" +doc.name = "find char pair" +doc.description = "To next character pair" +doc.combinedName = "char pair →/←" +doc.combinedDescription = "To next character pair" +doc.combinedKey = "s/shift+s" args.acceptAfter = 2 args.offset = "start" args.skip = "{{count-1}}" @@ -864,9 +864,9 @@ mode = "normal" [[bind]] default = "{{bind.edit_motion_search}}" key = "shift+s" -name = "char pair back" -description = "To previous character pair" -combinedName = "char pair →/←" +doc.name = "char pair back" +doc.description = "To previous character pair" +doc.combinedName = "char pair →/←" args.acceptAfter = 2 args.offset = "start" args.skip = "{{count-1}}" @@ -881,9 +881,9 @@ args.backwards = true default = "{{bind.edit_motion}}" key = "g" priority = 1 -name = "goto" +doc.name = "goto" command = "master-key.prefix" -description = """ +doc.description = """ Goto commands move the location of the cursor (or the active selection position) forward or backwards in some direction. """ @@ -892,14 +892,14 @@ or backwards in some direction. default = "{{bind.edit_motion_prim}}" key = "g j" priority = 1 -name = "unwrp ↓" -combinedName = "unwrap ↓/↑" -combinedKey = "j/k" -combinedDescription = """ +doc.name = "unwrp ↓" +doc.combinedName = "unwrap ↓/↑" +doc.combinedKey = "j/k" +doc.combinedDescription = """ move cursor up/down unwrapped text line; if a single line is wrapped into multiple lines by the editor, this command skips all such wrapped lines """ -description = """ +doc.description = """ down unwrapped line; if a single line is wrapped into multiple lines by the editor, this command skips all such wrapped lines """ @@ -910,9 +910,9 @@ args.by = "line" default = "{{bind.edit_motion_prim}}" key = "g k" priority = 1 -name = "unwrp ↑" -combinedName = "unwrap ↓/↑" -description = "up unwrapped line" +doc.name = "unwrp ↑" +doc.combinedName = "unwrap ↓/↑" +doc.description = "up unwrapped line" args.to = "up" args.by = "line" @@ -920,11 +920,11 @@ args.by = "line" default = "{{bind.edit_motion_prim}}" key = "g shift+k" priority = 1 -combinedName = "unwrp sel ↑/↓" -combinedDescription = "select unwrapped lines up/down" -combinedKey = "shift+k/j" -name = "unwrp sel ↑" -description = "select unwrapped lines upwards" +doc.combinedName = "unwrp sel ↑/↓" +doc.combinedDescription = "select unwrapped lines up/down" +doc.combinedKey = "shift+k/j" +doc.name = "unwrp sel ↑" +doc.description = "select unwrapped lines upwards" command = "runCommands" [[bind.args.commands]] @@ -942,9 +942,9 @@ command = "expandLineSelection" default = "{{bind.edit_motion_prim}}" key = "g shift+j" priority = 1 -name = "sel ↓" -combinedName = "unwrp sel ↑/↓" -description = "select unwrapped lines downwards" +doc.name = "sel ↓" +doc.combinedName = "unwrp sel ↑/↓" +doc.description = "select unwrapped lines downwards" command = "runCommands" [[bind.args.commands]] @@ -962,19 +962,19 @@ command = "expandLineSelection" default = "{{bind.edit_motion_prim}}" key = "shift+g" priority = 1 -name = "doc end" -description = "select to end of document" -combinedName = "doc top/bottom" -combinedDescription = "select to top/bottom of document" -combinedKey = ",/." +doc.name = "doc end" +doc.description = "select to end of document" +doc.combinedName = "doc top/bottom" +doc.combinedDescription = "select to top/bottom of document" +doc.combinedKey = ",/." command = "cursorBottomSelect" [[bind]] default = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 -name = "doc start" -description = "select to start (line) of document." +doc.name = "doc start" +doc.description = "select to start (line) of document." command = "runCommands" when = "master-key.count > 1" @@ -996,8 +996,8 @@ args.lineNumber = "{{count}}" default = "{{bind.edit_motion_prim}}" key = "g g" priority = 1 -name = "doc start" -description = "select to start of document" +doc.name = "doc start" +doc.description = "select to start of document" command = "cursorTopSelect" when = "master-key.count <= 1" @@ -1005,13 +1005,13 @@ when = "master-key.count <= 1" default = "{{bind.edit_motion_obj}}" key = "g w" priority = 1 -name = "WORD →" -combinedName = "WORD →/←" -combinedDescription = """ +doc.name = "WORD →" +doc.combinedName = "WORD →/←" +doc.combinedDescription = """ next/prev WORD; e.g. contiguous non-whitespace region """ -combinedKey = "w/b" -description = "next WORD; e.g. contiguous non-whitespace region" +doc.combinedKey = "w/b" +doc.description = "next WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" args.value = "{{count || 1}}" @@ -1019,9 +1019,9 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_obj}}" key = "g b" priority = 1 -name = "WORD ←" -combinedName = "WORD →/←" -description = "previous WORD; e.g. contiguous non-whitespace region" +doc.name = "WORD ←" +doc.combinedName = "WORD →/←" +doc.description = "previous WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" args.value = "{{-count || -1}}" @@ -1029,8 +1029,8 @@ args.value = "{{-count || -1}}" default = "{{bind.edit_motion_obj}}" key = "g e" priority = 1 -name = "WORD end →" -description = "next WORD end; e.g. contiguous non-whitespace region" +doc.name = "WORD end →" +doc.description = "next WORD end; e.g. contiguous non-whitespace region" args.unit = "BigWord" args.boundary = "end" args.value = "{{count || 1}}" @@ -1039,11 +1039,11 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_obj}}" key = "g 0" priority = 1 -name = "sec →" -description = "next section" -combinedName = "sec →/←" -combinedDescription = "next/previous section" -combinedKey = "0/9" +doc.name = "sec →" +doc.description = "next section" +doc.combinedName = "sec →/←" +doc.combinedDescription = "next/previous section" +doc.combinedKey = "0/9" args.unit = "section" args.value = "{{count || 1}}" @@ -1051,70 +1051,70 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_obj}}" key = "g 9" priority = 1 -name = "sec ←" -description = "previous section" -combinedName = "sec →/←" +doc.name = "sec ←" +doc.description = "previous section" +doc.combinedName = "sec →/←" args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.window}}" -name = "goto line" +doc.name = "goto line" priority = 1 -description = "goto line command" +doc.description = "goto line command" key = "g l" command = "workbench.action.gotoLine" [[bind]] default = "{{bind.window}}" -name = "to refs" +doc.name = "to refs" priority = 1 -description = "jump to a location where this symbol is referenced" +doc.description = "jump to a location where this symbol is referenced" key = "g r" command = "editor.action.goToReferences" [[bind]] default = "{{bind.window}}" -name = "go to" +doc.name = "go to" priority = 1 -description = "go to the definition of symbol under cursor" +doc.description = "go to the definition of symbol under cursor" key = "g d" -combinedName = "go to (aside)" -combinedKey = "(shift+)d" -combinedDescription = "go to the definition of symbol (in an editor to the side)" +doc.combinedName = "go to (aside)" +doc.combinedKey = "(shift+)d" +doc.combinedDescription = "go to the definition of symbol (in an editor to the side)" command = "editor.action.revealDefinition" [[bind]] default = "{{bind.window}}" -name = "go to, aside" +doc.name = "go to, aside" priority = 1 -description = "go to the definition of symbol under cursor in an editor to the side" +doc.description = "go to the definition of symbol under cursor in an editor to the side" key = "g shift+d" -combinedName = "go to (aside)" +doc.combinedName = "go to (aside)" command = "editor.action.revealDefinitionAside" [[bind]] default = "{{bind.window}}" -name = "open" -description = "open the file name under the cursor" +doc.name = "open" +doc.description = "open the file name under the cursor" key = "g f" command = "extension.openFileFromPath" [[bind]] default = "{{bind.edit_motion}}" key = "g c" -name = "cell →" -combinedName = "cell →/←" +doc.name = "cell →" +doc.combinedName = "cell →/←" command = "runCommands" args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] -description = "previous jupyter notebook cell" +doc.description = "previous jupyter notebook cell" [[bind]] default = "{{bind.edit_motion}}" key = "g shift+c" -name = "cell ←" -combinedName = "cell →/←" -description = "previous jupyter notebook cell" +doc.name = "cell ←" +doc.combinedName = "cell →/←" +doc.description = "previous jupyter notebook cell" command = "runCommands" args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] @@ -1128,70 +1128,70 @@ args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] id = "edit_motion_match_obj" default = "{{bind.edit_motion}}" command = "selection-utilities.moveBy" -kind = "motion" +doc.kind = "motion" args.selectWhole = true args.boundary = "start" [[bind]] default = "{{bind.edit_motion}}" key = "m" -name = "match" -description = """ +doc.name = "match" +doc.description = """ Find the closest character range matching a specified object. """ -kind = "motion" +doc.kind = "motion" command = "master-key.prefix" [[bind]] default = "{{bind.edit_motion}}" key = "m m" -name = "smart expand" -description = "Use VSCode's built-in smart expansion command" +doc.name = "smart expand" +doc.description = "Use VSCode's built-in smart expansion command" command = "editor.action.smartSelect.expand" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m w" -name = "around subwrd →" -description = "(camel/snake case)" -combinedName = "around subwrd ←/→" -combinedDescription = "(camel/snake case)" -combinedKey = "w/b" +doc.name = "around subwrd →" +doc.description = "(camel/snake case)" +doc.combinedName = "around subwrd ←/→" +doc.combinedDescription = "(camel/snake case)" +doc.combinedKey = "w/b" args.unit = "subword" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m b" -name = "around subwrd ←" -description = "(camel/snake case)" -combinedName = "around subwrd ←/→" +doc.name = "around subwrd ←" +doc.description = "(camel/snake case)" +doc.combinedName = "around subwrd ←/→" args.unit = "subword" args.value = "{{-count || -1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+w" -name = "ard word →" -combinedName = "around word →/←" -combinedKey = "shift+w/b" +doc.name = "ard word →" +doc.combinedName = "around word →/←" +doc.combinedKey = "shift+w/b" args.unit = "word" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+b" -name = "ard word ←" -combinedName = "around word →/←" +doc.name = "ard word ←" +doc.combinedName = "around word →/←" args.unit = "word" args.value = "{{-count || -1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m e" -name = "in subwrd" -combinedName = "in → subword/word" -combinedKey = "e/shift+e" +doc.name = "in subwrd" +doc.combinedName = "in → subword/word" +doc.combinedKey = "e/shift+e" args.unit = "subident" args.boundary = "both" args.value = "{{count || 1}}" @@ -1199,8 +1199,8 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+e" -name = "in word" -combinedName = "in → subword/word" +doc.name = "in word" +doc.combinedName = "in → subword/word" args.unit = "word" args.boundary = "both" args.value = "{{count || 1}}" @@ -1208,9 +1208,9 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m p" -name = "in parag. →" -combinedName = "in paragraph →/←" -combinedKey = "p/o" +doc.name = "in parag. →" +doc.combinedName = "in paragraph →/←" +doc.combinedKey = "p/o" args.boundary = "both" args.unit = "paragraph" args.value = "{{count || 1}}" @@ -1218,8 +1218,8 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m o" -name = "in parag. ←" -combinedName = "in paragraph →/←" +doc.name = "in parag. ←" +doc.combinedName = "in paragraph →/←" args.unit = "paragraph" args.boundary = "both" args.value = "{{-(count || 1)}}" @@ -1227,99 +1227,99 @@ args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+p" -name = "arn parag. →" -combinedName = "around paragraph →/←" -combinedKey = "shift+p/shift+o" +doc.name = "arn parag. →" +doc.combinedName = "around paragraph →/←" +doc.combinedKey = "shift+p/shift+o" args.unit = "paragraph" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+o" -name = "arn parag. ←" -combinedName = "around paragraph →/←" +doc.name = "arn parag. ←" +doc.combinedName = "around paragraph →/←" args.unit = "paragraph" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m 0" -name = "arn subsec →" -combinedName = "around subsection →/←" -combinedKey = "0/shift+0" +doc.name = "arn subsec →" +doc.combinedName = "around subsection →/←" +doc.combinedKey = "0/shift+0" args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+0" -name = "arn subsec ←" -combinedName = "around subsection →/←" +doc.name = "arn subsec ←" +doc.combinedName = "around subsection →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m 9" -name = "in subsec →" -combinedName = "in subsection →/←" -combinedKey = "9/shift+9" +doc.name = "in subsec →" +doc.combinedName = "in subsection →/←" +doc.combinedKey = "9/shift+9" args.unit = "subsection" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m shift+9" -name = "in subsec ←" -combinedName = "in subsection →/←" +doc.name = "in subsec ←" +doc.combinedName = "in subsection →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion}}" key = "m g" -name = "other..." -description = "additional objects to match..." +doc.name = "other..." +doc.description = "additional objects to match..." command = "master-key.prefix" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m g 0" -name = "section →" -combinedName = "section →/←" -combinedKey = "0/9" +doc.name = "section →" +doc.combinedName = "section →/←" +doc.combinedKey = "0/9" args.unit = "section" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m g 9" -name = "section ←" -combinedName = "section →/←" +doc.name = "section ←" +doc.combinedName = "section →/←" args.unit = "section" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m g w" -name = "around WORD →" -combinedName = "around WORD →/←" -combinedKey = "w/b" +doc.name = "around WORD →" +doc.combinedName = "around WORD →/←" +doc.combinedKey = "w/b" args.unit = "BigWord" args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m g b" -name = "around WORD ←" -combinedName = "around WORD →/←" +doc.name = "around WORD ←" +doc.combinedName = "around WORD →/←" args.unit = "BigWord" args.value = "{{-(count || 1)}}" [[bind]] default = "{{bind.edit_motion_match_obj}}" key = "m g e" -name = "in WORD" +doc.name = "in WORD" args.unit = "BigWord" args.boundary = "both" args.value = "{{count || 1}}" @@ -1327,14 +1327,14 @@ args.value = "{{count || 1}}" [[bind]] default = "{{bind.edit_motion}}" key = "m [" -name = "in parens" -combinedName = "in/arnd parens" -combinedKey = "[/shift+[" -combinedDescription = """ +doc.name = "in parens" +doc.combinedName = "in/arnd parens" +doc.combinedKey = "[/shift+[" +doc.combinedDescription = """ expand inside/around parens/brackets/braces and their contents; repeated calls to this command will seek out larger and larger scopes """ -description = """ +doc.description = """ expand inside parens/brackets/braces and their contents; repeated calls to this command will seek out larger and larger scopes """ @@ -1343,9 +1343,9 @@ command = "selection-utilities.expandWithinBrackets" [[bind]] default = "{{bind.edit_motion}}" key = "m shift+[" -name = "arnd parens" -combinedName = "in/arnd parens" -description = """ +doc.name = "arnd parens" +doc.combinedName = "in/arnd parens" +doc.description = """ expand inside parens/brackets/braces and their contents; repeated calls to this command will seek out larger and larger scopes """ @@ -1354,14 +1354,14 @@ command = "selection-utilities.expandAroundBrackets" [[bind]] default = "{{bind.edit_motion}}" key = "m '" -name = "in quotes" -description = """ +doc.name = "in quotes" +doc.description = """ select within current quotes; repeated calls to this command will seek out larger and larger scopes """ -combinedName = "in/arnd quotes" -combinedKey = "'/shift+'" -combinedDescription = """ +doc.combinedName = "in/arnd quotes" +doc.combinedKey = "'/shift+'" +doc.combinedDescription = """ select within/around current quotes; repeated calls to this command will seek out larger and larger scopes """ @@ -1370,9 +1370,9 @@ command = "bracketeer.selectQuotesContent" [[bind]] default = "{{bind.edit_motion}}" key = "m shift+'" -name = "around quotes" -combinedName = "in/arnd quotes" -description = """ +doc.name = "around quotes" +doc.combinedName = "in/arnd quotes" +doc.description = """ select around current quotes; repeated calls to this command will seek out larger and larger scopes """ @@ -1382,29 +1382,29 @@ args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesConte [[bind]] default = "{{bind.edit_motion}}" key = "m shift+." -name = "in <>" -description = "text inside angle brackets" -combinedName = "in <> / in ><" -combinedKey = "shift+. / shift+," -combinedDescription = "text inside angle brackets / pairs (e.g. text in text)" +doc.name = "in <>" +doc.description = "text inside angle brackets" +doc.combinedName = "in <> / in ><" +doc.combinedKey = "shift+. / shift+," +doc.combinedDescription = "text inside angle brackets / pairs (e.g. text in text)" command = "extension.selectAngleBrackets" [[bind]] default = "{{bind.edit_motion}}" key = "m shift+," -name = "in ><" -combinedName = "in <> / in ><" -description = "text inside tag pairs (e.g. text)" +doc.name = "in ><" +doc.combinedName = "in <> / in ><" +doc.description = "text inside tag pairs (e.g. text)" command = "extension.selectInTag" [[bind]] default = "{{bind.edit_motion}}" key = "m i" -name = "in indent" -description = "all text at the same indentation level" -combinedName = "in/arnd" -combinedKey = "space/shift+space" -combinedDescription = """ +doc.name = "in indent" +doc.description = "all text at the same indentation level" +doc.combinedName = "in/arnd" +doc.combinedKey = "space/shift+space" +doc.combinedDescription = """ all text at the same indentation level / all indentation along with the line above and below this (ala c-like syntax) """ @@ -1413,35 +1413,35 @@ command = "vscode-select-by-indent.select-inner" [[bind]] default = "{{bind.edit_motion}}" key = "m shift+i" -name = "arnd indent" -description = """ +doc.name = "arnd indent" +doc.description = """ all text at the same indentation level along with the line above and below this (ala c-like syntax) """ -combinedName = "in/arnd" +doc.combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer" [[bind]] default = "{{bind.edit_motion}}" key = "m g i" -name = "indent+top" -description = """ +doc.name = "indent+top" +doc.description = """ all text at the same indentation level and the line just above it (ala python syntax) """ -combinedName = "in/arnd" +doc.combinedName = "in/arnd" command = "vscode-select-by-indent.select-outer-top-only" [[bind]] default = "{{bind.edit_motion}}" -name = "in cell" -description = "select text within a cell (ala jupyter)" +doc.name = "in cell" +doc.description = "select text within a cell (ala jupyter)" key = "m c" command = "jupyter.selectCell" [[bind]] default = "{{bind.edit_motion}}" -name = "between pair" -combinedDescription = """ +doc.name = "between pair" +doc.combinedDescription = """ Select between pairs of the same N characters (t) or distinct sets of N characters (s), where N is the count. Examples: 2mt'' would search for a string between `''` and `''`. @@ -1449,9 +1449,9 @@ characters (s), where N is the count. Examples: """ key = "m t" command = "runCommands" -combinedName = "between pair/two" -combinedKey = "t/s" -description = """ +doc.combinedName = "between pair/two" +doc.combinedKey = "t/s" +doc.description = """ Select between pairs of the same N characters, where N is the count. Example: 2mt'' would search for a string between '' and ''. """ @@ -1467,13 +1467,13 @@ args.inclusive = false [[bind]] default = "{{bind.edit_motion}}" -name = "between two" -description = """ +doc.name = "between two" +doc.description = """ Select between two different sets of N characters, where N is the count e.g. 2ms,,.. would search for a string between ,, and .. """ key = "m s" -combinedName = "between pair/two" +doc.combinedName = "between pair/two" command = "runCommands" [[bind.args.commands]] @@ -1493,7 +1493,7 @@ args.inclusive = false [[define.bind]] id = "edit_action" -kind = "action" +doc.kind = "action" mode = "normal" tags = ["action"] @@ -1501,8 +1501,8 @@ tags = ["action"] default = "{{bind.edit_action}}" #- TODO: add documentation to these basic editor keys key = "i" -name = "insert" -description = "Switch to insert mode (right before character)" +doc.name = "insert" +doc.description = "Switch to insert mode (right before character)" command = "runCommands" args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' @@ -1510,8 +1510,8 @@ mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' [[bind]] default = "{{bind.edit_action}}" key = "a" -name = "append" -description = "insert after cursor" +doc.name = "append" +doc.description = "insert after cursor" mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ @@ -1523,7 +1523,7 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+i" -name = "insert start" +doc.name = "insert start" mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ @@ -1534,7 +1534,7 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+a" -name = "insert end" +doc.name = "insert end" mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ @@ -1545,8 +1545,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "c" -name = "change" -description = """ +doc.name = "change" +doc.description = """ Without a count: change selected region of text. With a count: change up to `count` lines. """ @@ -1588,8 +1588,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+c" -name = "change to/back" -description = """Without a count: change from current char to end of line. With a count: +doc.name = "change to/back" +doc.description = """Without a count: change from current char to end of line. With a count: change the previous `count` lines. """ mode = "normal" @@ -1623,32 +1623,32 @@ args.commands = [ ] key = "x" mode = "normal" -name = "delete char" +doc.name = "delete char" command = "runCommands" [[bind]] default = "{{bind.edit_action}}" key = "r" -name = "replace char" -description = "replace the character under the cursor" +doc.name = "replace char" +doc.description = "replace the character under the cursor" command = "master-key.replaceChar" [[bind]] default = "{{bind.edit_action}}" key = "ctrl+i" -name = "insert char" +doc.name = "insert char" mode = '{{all_modes_but(["normal", "selectedit"]}}' -description = "insert a character in front of the cursor" +doc.description = "insert a character in front of the cursor" command = "master-key.insertChar" [[bind]] default = "{{bind.edit_action}}" key = "p" -name = "paste after" -description = "Paste clipboard after the cursor/selection" -combinedName = "paste before/after/in" -combinedDescription = "Paste clipboard before/after/at the cursor/selection" -combinedKey = "p/shift+p/ctrl+p" +doc.name = "paste after" +doc.description = "Paste clipboard after the cursor/selection" +doc.combinedName = "paste before/after/in" +doc.combinedDescription = "Paste clipboard before/after/at the cursor/selection" +doc.combinedKey = "p/shift+p/ctrl+p" when = "editorHasSelection" command = "runCommands" args.commands = [ @@ -1660,8 +1660,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "p" -name = "paste after" -combinedName = "paste before/after/in" +doc.name = "paste after" +doc.combinedName = "paste before/after/in" when = "!editorHasSelection" command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] @@ -1671,17 +1671,17 @@ default = "{{bind.edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" mode = '{{all_modes_but(["normal", "insert"]}}' -name = "paste in" -combinedName = "paste before/after/in" -description = "Paste clipboard at location" +doc.name = "paste in" +doc.combinedName = "paste before/after/in" +doc.description = "Paste clipboard at location" command = "editor.action.clipboardPasteAction" [[bind]] default = "{{bind.edit_action}}" key = "shift+p" -name = "paste before" -combinedName = "paste before/after" -description = "Paste before the cursor/selection" +doc.name = "paste before" +doc.combinedName = "paste before/after" +doc.description = "Paste before the cursor/selection" when = "editorHasSelection" command = "runCommands" args.commands = [ @@ -1693,15 +1693,15 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+p" -combinedName = "paste before/after" +doc.combinedName = "paste before/after" when = "!editorHasSelection" command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] [[bind]] default = "{{bind.edit_action_history}}" -name = "repeat action" -description = """ +doc.name = "repeat action" +doc.description = """ Repeat the last action command. Actions usually modify the text of a document in one way or another. (But, e.g. sending text to the REPL is also considered an editor action). See also `,` which repeats the last subject. @@ -1724,30 +1724,30 @@ command = "master-key.enterNormal" [[bind]] default = "{{bind.edit_action_history}}" -name = "undo" +doc.name = "undo" key = "u" command = "runCommands" args.commands = ["undo", "selection-utilities.shrinkToActive"] [[bind]] default = "{{bind.edit_action_history}}" -name = "redo" +doc.name = "redo" key = "shift+u" command = "runCommands" args.commands = ["redo", "selection-utilities.shrinkToActive"] [[bind]] default = "{{bind.edit_action}}" -name = 'toggle check' -description = "Toggle a markdown checkbox" +doc.name = 'toggle check' +doc.description = "Toggle a markdown checkbox" key = "shift+6" command = "markdown-checkbox.markCheckbox" [[bind]] default = "{{bind.edit_action}}" key = "d" -name = "delete" -description = """ +doc.name = "delete" +doc.description = """ Without a count: delete selected text (and store to clipboard). With a count, delete up to the next `count` lines and store to clipboard. """ @@ -1773,7 +1773,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "shift+d" mode = "normal" -name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." +doc.name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", @@ -1792,8 +1792,8 @@ args.commands = ["{{command.selectLinesUp}}", "deleteRight"] [[bind]] default = "{{bind.edit_action}}" key = "y" -name = "copy" -description = "copy selected text to clipboard" +doc.name = "copy" +doc.description = "copy selected text to clipboard" command = "runCommands" args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] @@ -1811,8 +1811,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+y" -name = "copy (eol/up)" -description = "without a count: copy to end of line; with a count: copy this and the previous N lines" +doc.name = "copy (eol/up)" +doc.description = "without a count: copy to end of line; with a count: copy this and the previous N lines" when = "master-key.count <= 1" command = "runCommands" args.commands = [ @@ -1836,25 +1836,25 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+." -name = "indent" -description = "Indent lines" +doc.name = "indent" +doc.description = "Indent lines" command = "editor.action.indentLines" [[bind]] args.commands = ["{{command.selectLinesDown}}", "editor.action.indentLines"] default = "{{bind.edit_action}}" key = "shift+." -name = "indent" -description = "Indent lines" +doc.name = "indent" +doc.description = "Indent lines" when = "master-key.count >= 1" command = "runCommands" [[bind]] default = "{{bind.edit_action}}" key = "shift+," -name = "deindent" +doc.name = "deindent" when = "master-key.count < 1" -description = "De-indent lines" +doc.description = "De-indent lines" command = "editor.action.outdentLines" [[bind]] @@ -1865,9 +1865,9 @@ args.commands = [ ] default = "{{bind.edit_action}}" key = "shift+," -name = "deindent" +doc.name = "deindent" when = "master-key.count >= 1" -description = "Deindent lines" +doc.description = "Deindent lines" command = "runCommands" [[define.bind]] @@ -1881,15 +1881,15 @@ tags = ["history"] [[bind]] default = "{{bind.edit_action}}" -name = 'inc #' -description = "Increment a number by 1" +doc.name = 'inc #' +doc.description = "Increment a number by 1" key = "=" command = "selection-utilities.incrementNumber" [[bind]] default = "{{bind.edit_action}}" -name = 'dec #' -description = "Decrement a number by 1 " +doc.name = 'dec #' +doc.description = "Decrement a number by 1 " key = "shift+=" command = "selection-utilities.decrementNumber" @@ -1904,99 +1904,99 @@ mode = '{{all_modes_but(["normal", "selectedit"]}}' [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'camel' -description = "Swap style to lower camel case (`camelCase`)" +doc.name = 'camel' +doc.description = "Swap style to lower camel case (`camelCase`)" key = "` c" command = "extension.changeCase.camel" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'constant' -description = "Swap style to constant (`IS_CONSTANT`)" +doc.name = 'constant' +doc.description = "Swap style to constant (`IS_CONSTANT`)" key = "` shift+u" command = "extension.changeCase.constant" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'dot' -description = "Swap style to dot case (`dot.case`)" +doc.name = 'dot' +doc.description = "Swap style to dot case (`dot.case`)" key = "` ." command = "extension.changeCase.dot" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'kebab' -description = "Swap style to kebab case (`kebab-case`)" +doc.name = 'kebab' +doc.description = "Swap style to kebab case (`kebab-case`)" key = "` -" command = "extension.changeCase.kebab" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'all lower' -description = "Swap all to lower case" +doc.name = 'all lower' +doc.description = "Swap all to lower case" key = "` shift+l" command = "extension.changeCase.lower" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'first lower' -description = "Swap first letter to lower case" +doc.name = 'first lower' +doc.description = "Swap first letter to lower case" key = "` l" command = "extension.changeCase.lowerFirst" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'spaces' -description = "Swap to spaces (`camelCase` -> `camel case`)" +doc.name = 'spaces' +doc.description = "Swap to spaces (`camelCase` -> `camel case`)" key = "` space" command = "extension.changeCase.no" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'Camel' -description = "Swap to upper camel case (`CamelCase`)" +doc.name = 'Camel' +doc.description = "Swap to upper camel case (`CamelCase`)" key = "` shift+c" command = "extension.changeCase.pascal" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'path' -description = "Swap to 'path' case (`path/case`)" +doc.name = 'path' +doc.description = "Swap to 'path' case (`path/case`)" key = "` /" command = "extension.changeCase.path" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'snake' -description = "Swap to snake case (`snake_case`)" +doc.name = 'snake' +doc.description = "Swap to snake case (`snake_case`)" key = "` shift+-" command = "extension.changeCase.snake" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'swap' -description = "Swap upper and lower case letters" +doc.name = 'swap' +doc.description = "Swap upper and lower case letters" key = "` s" command = "extension.changeCase.swap" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'title' -description = "Swap to title case (all words have first upper case letter)" +doc.name = 'title' +doc.description = "Swap to title case (all words have first upper case letter)" key = "` t" command = "extension.changeCase.title" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'all upper' -description = "Swap to use all upper case letters" +doc.name = 'all upper' +doc.description = "Swap to use all upper case letters" key = "` shift+y" command = "extension.changeCase.upper" [[bind]] default = "{{bind.edit_action_capitals}}" -name = 'first upper' -description = "Swap first character to upper case" +doc.name = 'first upper' +doc.description = "Swap first character to upper case" key = "` u" command = "extension.changeCase.upperFirst" @@ -2006,17 +2006,17 @@ command = "extension.changeCase.upperFirst" [[bind]] default = "{{bind.edit_action}}" -name = "do" +doc.name = "do" key = "space" -description = "additional actions, mostly for modifying specific syntactic formats" +doc.description = "additional actions, mostly for modifying specific syntactic formats" command = "master-key.prefix" [[bind]] default = "{{bind.edit_action}}" -name = "paste after line" -combinedName = "paste after/before line" -combinedKey = "p/shift+p" -description = "Paste text after current line" +doc.name = "paste after line" +doc.combinedName = "paste after/before line" +doc.combinedKey = "p/shift+p" +doc.description = "Paste text after current line" priority = 2 key = "space p" command = "runCommands" @@ -2030,9 +2030,9 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" priority = 2 -name = "paste before line" -combinedName = "paste after/before line" -description = "Paste text before current line" +doc.name = "paste before line" +doc.combinedName = "paste after/before line" +doc.description = "Paste text before current line" key = "space shift+p" command = "runCommands" args.commands = [ @@ -2045,32 +2045,32 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" priority = 2 -name = "add line below" -combinedName = "add line below/above" -combinedDescription = "open a line below/above current line" -combinedKey = "o/shift+o" -description = "open a line below current line" +doc.name = "add line below" +doc.combinedName = "add line below/above" +doc.combinedDescription = "open a line below/above current line" +doc.combinedKey = "o/shift+o" +doc.description = "open a line below current line" key = "space o" command = "editor.action.insertLineAfter" [[bind]] default = "{{bind.edit_action}}" -name = "add line above" +doc.name = "add line above" priority = 2 -combinedName = "add line below/above" -description = "open a line above current line" +doc.combinedName = "add line below/above" +doc.description = "open a line above current line" key = "space shift+o" command = "editor.action.insertLineBefore" [[bind]] default = "{{bind.edit_action}}" -name = 'sym insert' -description = "Insert a character pair around a character" +doc.name = 'sym insert' +doc.description = "Insert a character pair around a character" priority = 1 key = "space i" -combinedName = "sym insert (mode)" -combinedDescription = "Insert characters around pair (switching to syminster mode until hitting again)" -combinedKey = "i/shift+i" +doc.combinedName = "sym insert (mode)" +doc.combinedDescription = "Insert characters around pair (switching to syminster mode until hitting again)" +doc.combinedKey = "i/shift+i" command = "runCommands" [[bind.args.commands]] @@ -2085,26 +2085,26 @@ args.followCursor = true [[bind]] default = "{{bind.edit_action}}" -name = 'trim white' -description = "Delete all external whitespace (left and right edges)" +doc.name = 'trim white' +doc.description = "Delete all external whitespace (left and right edges)" key = "space shift+-" command = "selection-utilities.trimWhitespace" [[bind]] default = "{{bind.edit_action}}" key = "space w" -name = "wrap p" -combinedName = "wrap/join lines" -description = "wrap paragraph text, preserving commenting" -combinedDescription = "wrap paragraph text, preserving commenting / join lines together" -combinedKey = "w/j" +doc.name = "wrap p" +doc.combinedName = "wrap/join lines" +doc.description = "wrap paragraph text, preserving commenting" +doc.combinedDescription = "wrap paragraph text, preserving commenting / join lines together" +doc.combinedKey = "w/j" command = "rewrap.rewrapComment" [[bind]] default = "{{bind.edit_action}}" -name = 'join' -combinedName = "wrap/join lines" -description = "Remove newline between current and next line" +doc.name = 'join' +doc.combinedName = "wrap/join lines" +doc.description = "Remove newline between current and next line" key = "space j" mode = '{{all_modes_but(["normal", "selectedit"]}}' when = "!editorHasSelection" @@ -2113,9 +2113,9 @@ args.commands = ["{{command.selectLinesDown}}", 'editor.action.joinLines'] [[bind]] default = "{{bind.edit_action}}" -combinedName = "wrap/join lines" -name = 'join' -description = "Remove newline between current and next line" +doc.combinedName = "wrap/join lines" +doc.name = 'join' +doc.description = "Remove newline between current and next line" mode = '{{all_modes_but(["normal", "selectedit"]}}' key = "space j" command = "editor.action.joinLines" @@ -2123,8 +2123,8 @@ command = "editor.action.joinLines" [[bind]] default = "{{bind.edit_action}}" key = "space f" -name = "format" -combinedName = "format / format document" +doc.name = "format" +doc.combinedName = "format / format document" when = "master-key.count < 1" command = "editor.action.formatSelection" @@ -2136,67 +2136,67 @@ args.commands = [ ] default = "{{bind.edit_action}}" key = "space f" -combinedName = "format / format document" -combinedKey = "f/shift+f" -combinedDescription = "Format selection / document" -name = "format" -description = "Format sel" +doc.combinedName = "format / format document" +doc.combinedKey = "f/shift+f" +doc.combinedDescription = "Format selection / document" +doc.name = "format" +doc.description = "Format sel" when = "master-key.count >= 1" command = "runCommands" [[bind]] default = "{{bind.edit_action}}" key = "space shift+f" -name = "format doc" -combinedName = "format / format document" +doc.name = "format doc" +doc.combinedName = "format / format document" command = "editor.action.formatDocument" [[bind]] default = "{{bind.edit_action}}" -name = 'parens' -description = "actions related to various brackets (`[`, `(`, `{`)" +doc.name = 'parens' +doc.description = "actions related to various brackets (`[`, `(`, `{`)" key = "space [" command = "master-key.prefix" [[bind]] default = "{{bind.edit_action}}" -name = 'remove' -description = "Removes surrounding pairs" +doc.name = 'remove' +doc.description = "Removes surrounding pairs" key = "space [ d" command = "bracketeer.removeBrackets" [[bind]] default = "{{bind.edit_action}}" -name = 'parens/brackets' -description = "Swap between `[`, `(` and `{`" +doc.name = 'parens/brackets' +doc.description = "Swap between `[`, `(` and `{`" key = "space [ s" command = "bracketeer.swapBrackets" [[bind]] default = "{{bind.edit_action}}" -name = 'quotes' -description = "Actions related to quotes" +doc.name = 'quotes' +doc.description = "Actions related to quotes" key = "space '" command = "master-key.prefix" [[bind]] default = "{{bind.edit_action}}" -name = 'remove' -description = "Removes quotes (', \" or `)" +doc.name = 'remove' +doc.description = "Removes quotes (', \" or `)" key = "space ' d" command = "bracketeer.removeQuotes" [[bind]] default = "{{bind.edit_action}}" -name = 'swap' -description = "Swap quotes (', \" or `)" +doc.name = 'swap' +doc.description = "Swap quotes (', \" or `)" key = "space ' s" command = "bracketeer.swapQuotes" [[bind]] default = "{{bind.edit_action}}" key = "space /" -combinedName = "(block) comment" +doc.combinedName = "(block) comment" when = "master-key.count < 1" command = "editor.action.commentLine" @@ -2204,11 +2204,11 @@ command = "editor.action.commentLine" args.commands = ["{{command.selectLinesDown}}", "editor.action.commentLine"] default = "{{bind.edit_action}}" key = "space /" -name = "comment lines" -combinedName = "(block) comment" -combinedDescription = "Toggle (block) comment" -combinedKey = "(shift+)/" -description = "select next comment" +doc.name = "comment lines" +doc.combinedName = "(block) comment" +doc.combinedDescription = "Toggle (block) comment" +doc.combinedKey = "(shift+)/" +doc.description = "select next comment" when = "master-key.count >= 1" command = "runCommands" @@ -2216,7 +2216,7 @@ command = "runCommands" default = "{{bind.edit_action}}" key = "space shift+/" when = "master-key.count < 1" -combinedName = "(block) comment" +doc.combinedName = "(block) comment" command = "editor.action.blockComment" [[bind]] @@ -2227,34 +2227,34 @@ args.commands = [ ] default = "{{bind.edit_action}}" key = "space shift+/" -name = "block comment lines" -combinedName = "(block) comment" -description = "select previous comment" +doc.name = "block comment lines" +doc.combinedName = "(block) comment" +doc.description = "select previous comment" when = "master-key.count >= 1" command = "runCommands" [[bind]] default = "{{bind.edit_action}}" -name = 'inc all #' -combinedName = "inc/dec all #" -combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" -combinedKey = "=/shift+=" -description = "Increment selected numbers; increment increases per selection" +doc.name = 'inc all #' +doc.combinedName = "inc/dec all #" +doc.combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" +doc.combinedKey = "=/shift+=" +doc.description = "Increment selected numbers; increment increases per selection" key = "space =" command = "selection-utilities.incrementNumberPerSelection" [[bind]] default = "{{bind.edit_action}}" -name = 'dec all #' -combinedName = "inc/dec all #" -description = "Decrement selected numbers; decrement increases per selection" +doc.name = 'dec all #' +doc.combinedName = "inc/dec all #" +doc.description = "Decrement selected numbers; decrement increases per selection" key = "space shift+=" command = "selection-utilities.decrementNumberPerSelection" [[bind]] default = "{{bind.edit_action}}" -name = 'nb cell' -description = "Actions related to notebook cells" +doc.name = 'nb cell' +doc.description = "Actions related to notebook cells" key = "space c" command = "master-key.prefix" @@ -2263,8 +2263,8 @@ default = "{{bind.edit_action}}" key = "space c i" when = "editorLangId == 'quarto'" command = "quarto.insertCodeCell" -name = "insert cell" -description = "insert a new cell in a notebook" +doc.name = "insert cell" +doc.description = "insert a new cell in a notebook" [[bind]] default = "{{bind.edit_action}}" @@ -2275,8 +2275,8 @@ command = "jupyter.selectCell" [[bind]] default = "{{bind.edit_action}}" key = "space ." -name = 'sent. lines' -description = "Split paragraph into one line per sentence" +doc.name = 'sent. lines' +doc.description = "Split paragraph into one line per sentence" mode = "normal" command = "runCommands" @@ -2312,8 +2312,8 @@ command = "selection-utilities.cancelSelection" [[bind]] default = "{{bind.edit_action_history}}" -name = "record" -description = "Start/stop recording Master Key commands" +doc.name = "record" +doc.description = "Start/stop recording Master Key commands" key = "shift+q" when = "!master-key.record" command = "master-key.record" @@ -2321,8 +2321,8 @@ args.on = true [[bind]] default = "{{bind.edit_action_history}}" -name = "record" -description = """ +doc.name = "record" +doc.description = """ Start/stop recording key presses defined by Master Key pushing it to the top of the `history` stack once recording finishes." """ @@ -2341,8 +2341,8 @@ args.whereRangeIs.to = "{{index}}" [[bind]] default = "{{bind.edit_action_history}}" -name = "replay" -description = """ +doc.name = "replay" +doc.description = """ Replay the Master Key command sequence at the top of the `history` stack. Specifying a count requests the Nth most recent item on this stack. """ @@ -2352,21 +2352,21 @@ args.index = "{{count}}" [[bind]] default = "{{bind.edit_action_history}}" -name = "store macro" -description = """ +doc.name = "store macro" +doc.description = """ Stores the top of the `history` stack into a named register. Specifying a count stores the Nth most recent item on this stack. """ key = "q s" command = "master-key.storeNamed" -args.description = "Save Macro" +args.doc.description = "Save Macro" args.register = "macro" args.contents = "macro[macro.length-(count || 0)-1]" [[bind]] default = "{{bind.edit_action_history}}" -name = "replay stored" -description = """ +doc.name = "replay stored" +doc.description = """ Replay a recorded Master Key command sequence from a named register, pushing it to the front of the history stack. """ @@ -2375,7 +2375,7 @@ command = "runCommands" [[bind.args.commands]] command = "master-key.restoreNamed" -args.description = "Macro" +args.doc.description = "Macro" args.register = "macro" [[bind.args.commands]] @@ -2388,8 +2388,8 @@ args.index = 0 [[bind]] default = "{{bind.edit_action_history}}" -name = "store last" -description = """ +doc.name = "store last" +doc.description = """ Store the N most recently run commands as a macro, where N is the count (defaulting to 1). """ key = "q l" @@ -2404,12 +2404,12 @@ args.whereRangeIs.to = "{{index}}" [[bind]] default = "{{bind.window}}" key = "shift+ctrl+;" -name = "palette" +doc.name = "palette" finalKey = false -hideInPalette = true +doc.hideInPalette = true mode = "{{all_modes()}}" prefixes = "{{all_prefixes()}}" -description = """ +doc.description = """ show command suggestions within the context of the current mode and keybinding prefix (if any keys have already been typed) """ @@ -2417,64 +2417,64 @@ command = "master-key.commandPalette" [[bind]] default = "{{bind.util}}" -name = "git..." -description = "git commands" +doc.name = "git..." +doc.description = "git commands" key = "tab g" command = "master-key.prefix" [[bind]] default = "{{bind.util}}" -name = "pull" -combinedName = "push/pull" -description = "pull changes from remote" -combinedDescription = "pull from/push to remote" -combinedKey = "p/shift+p" +doc.name = "pull" +doc.combinedName = "push/pull" +doc.description = "pull changes from remote" +doc.combinedDescription = "pull from/push to remote" +doc.combinedKey = "p/shift+p" key = "tab g p" command = "git.pull" [[bind]] default = "{{bind.util}}" -name = "push" -description = "push changes to remote" +doc.name = "push" +doc.description = "push changes to remote" key = "tab g shift+p" command = "git.push" [[bind]] default = "{{bind.util}}" -name = "checkout" -combinedName = "commit/checkout" -description = "commit changes" -combinedDescription = "commit/checkout git changes" -combinedKey = "c/shift+c" +doc.name = "checkout" +doc.combinedName = "commit/checkout" +doc.description = "commit changes" +doc.combinedDescription = "commit/checkout git changes" +doc.combinedKey = "c/shift+c" key = "tab g c" command = "git.commit" [[bind]] default = "{{bind.util}}" -name = "checkout" -combinedName = "commit/checkout" -description = "checkout changes" +doc.name = "checkout" +doc.combinedName = "commit/checkout" +doc.description = "checkout changes" key = "tab g shift+c" command = "git.checkout" [[bind]] default = "{{bind.util}}" -name = "revert range" -description = "revert unstaged changes in selected range" +doc.name = "revert range" +doc.description = "revert unstaged changes in selected range" key = "tab g r" command = "git.revertSelectedRanges" [[bind]] default = "{{bind.util}}" -name = "revert range" -description = "revert unstaged changes in selected range" +doc.name = "revert range" +doc.description = "revert unstaged changes in selected range" key = "tab g s" command = "git.stageSelectedRanges" [[bind]] default = "{{bind.util}}" -name = "commands..." -description = "show GitLens command palette for git" +doc.name = "commands..." +doc.description = "show GitLens command palette for git" key = "tab g g" command = "gitlens.gitCommands" @@ -2488,88 +2488,88 @@ when = "editorTextFocus && !findWidgetVisible" [[bind]] default = "{{bind.util}}" -name = "utility" +doc.name = "utility" key = "tab" -description = "utility related commands: file opening, window manipulation, debugging etc..." +doc.description = "utility related commands: file opening, window manipulation, debugging etc..." command = "master-key.prefix" [[bind]] default = "{{bind.util}}" -name = "open recent" -description = "Open recent file" +doc.name = "open recent" +doc.description = "Open recent file" key = "tab r" command = "workbench.action.openRecent" [[bind]] default = "{{bind.util}}" -name = "hover" -description = "show the hover view" -combinedName = "(debug) hover" -combinedDescription = "show the (debug) hover view" -combinedKey = "(shift+)h" +doc.name = "hover" +doc.description = "show the hover view" +doc.combinedName = "(debug) hover" +doc.combinedDescription = "show the (debug) hover view" +doc.combinedKey = "(shift+)h" key = "tab h" command = "editor.action.showHover" [[bind]] default = "{{bind.util}}" -name = "debug hover" -combinedName = "(debug) hover" -description = "show the debug hover view" +doc.name = "debug hover" +doc.combinedName = "(debug) hover" +doc.description = "show the debug hover view" key = "tab shift+h" command = "editor.debug.action.showDebugHover" [[bind]] default = "{{bind.util}}" -name = "add mark" -combinedName = "add mark / mark..." -description = "toggle bookmark at given line" -combinedDescription = """ +doc.name = "add mark" +doc.combinedName = "add mark / mark..." +doc.description = "toggle bookmark at given line" +doc.combinedDescription = """ toggle bookmark at given line / bookmark related commands """ key = "tab shift+m" -combinedKey = "shift+m / m" +doc.combinedKey = "shift+m / m" command = "vsc-labeled-bookmarks.toggleBookmark" [[bind]] default = "{{bind.util}}" -name = "mark" -combinedName = "add mark / mark..." -description = "bookmark related commands" +doc.name = "mark" +doc.combinedName = "add mark / mark..." +doc.description = "bookmark related commands" key = "tab m" command = "master-key.prefix" [[bind]] default = "{{bind.util}}" -name = "mark ↓" -description = "move to next bookmark" -combinedName = "mark ↓/↑" -combinedDescription = "move to next/previous bookmark" -combinedKey = "j/k" +doc.name = "mark ↓" +doc.description = "move to next bookmark" +doc.combinedName = "mark ↓/↑" +doc.combinedDescription = "move to next/previous bookmark" +doc.combinedKey = "j/k" key = "tab m j" when = "!master-key.var.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] default = "{{bind.util}}" -combinedName = "mark ↓/↑" +doc.combinedName = "mark ↓/↑" key = "tab m j" when = "master-key.var.select || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] default = "{{bind.util}}" -name = "mark ↑" -combinedName = "mark ↓/↑" -description = "move to previous bookmark" +doc.name = "mark ↑" +doc.combinedName = "mark ↓/↑" +doc.description = "move to previous bookmark" key = "tab m k" when = "!master-key.var.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] default = "{{bind.util}}" -name = "mark ↑" -combinedName = "mark ↓/↑" -description = "move to previous bookmark" +doc.name = "mark ↑" +doc.combinedName = "mark ↓/↑" +doc.description = "move to previous bookmark" key = "tab m k" when = "master-key.var.select || editorHasSelection" command = "runCommands" @@ -2580,25 +2580,25 @@ args.commands = [ [[bind]] default = "{{bind.util}}" -name = "remove mark" -description = "remove bookmark (use quick selection)" +doc.name = "remove mark" +doc.description = "remove bookmark (use quick selection)" key = "tab m d" command = "vsc-labeled-bookmarks.deleteBookmark" [[bind]] default = "{{bind.util}}" -name = "nav marks" -description = "reveal quick selection to move to a bookmark" +doc.name = "nav marks" +doc.description = "reveal quick selection to move to a bookmark" key = "tab m t" command = "vsc-labeled-bookmarks.navigateToBookmark" [[bind]] default = "{{bind.util}}" -name = "error →" -combinedName = "error →/←" -combinedDescription = "move to next/previous error" -combinedKey = "e/shift+e" -description = """ +doc.name = "error →" +doc.combinedName = "error →/←" +doc.combinedDescription = "move to next/previous error" +doc.combinedKey = "e/shift+e" +doc.description = """ move to next error """ key = "tab e" @@ -2606,9 +2606,9 @@ command = "editor.action.marker.next" [[bind]] default = "{{bind.edit_motion}}" -name = "error ←" -combinedName = "error →/←" -description = """ +doc.name = "error ←" +doc.combinedName = "error →/←" +doc.description = """ move to previous error """ key = "tab shift+e" @@ -2616,11 +2616,11 @@ command = "editor.action.marker.prev" [[bind]] default = "{{bind.edit_motion}}" -name = "diff →" -combinedName = "diff →/←" -combinedDescription = "move to and show next/previous diff" -combinedKey = "c/shift+c" -description = """ +doc.name = "diff →" +doc.combinedName = "diff →/←" +doc.combinedDescription = "move to and show next/previous diff" +doc.combinedKey = "c/shift+c" +doc.description = """ move to and show next diff """ key = "tab c" @@ -2628,9 +2628,9 @@ command = "editor.action.dirtydiff.next" [[bind]] default = "{{bind.edit_motion}}" -name = "diff ←" -combinedName = "diff →/←" -description = """ +doc.name = "diff ←" +doc.combinedName = "diff →/←" +doc.description = """ move to and show previous diff """ key = "tab shift+c" @@ -2638,11 +2638,11 @@ command = "editor.action.dirtydiff.previous" [[bind]] default = "{{bind.edit_motion}}" -name = "change →" -combinedName = "change →/←" -combinedDescription = "move to next/previous file change" -combinedKey = "d/shift+d" -description = """ +doc.name = "change →" +doc.combinedName = "change →/←" +doc.combinedDescription = "move to next/previous file change" +doc.combinedKey = "d/shift+d" +doc.description = """ move to next file change """ key = "tab d" @@ -2650,9 +2650,9 @@ command = "workbench.action.editor.nextChange" [[bind]] default = "{{bind.edit_motion}}" -name = "change ←" -combinedName = "change →/←" -description = """ +doc.name = "change ←" +doc.combinedName = "change →/←" +doc.description = """ move to previous change """ key = "tab shift+d" @@ -2664,168 +2664,168 @@ command = "workbench.action.editor.previousChange" [[define.bind]] id = "window" -kind = "util" +doc.kind = "util" mode = "normal" when = "editorTextFocus && !findWidgetVisible" [[bind]] default = "{{bind.window}}" -name = "cntr win" -description = "center window at primary cursor position" +doc.name = "cntr win" +doc.description = "center window at primary cursor position" key = "tab l" command = "selection-utilities.revealActive" args.at = "center" [[bind]] default = "{{bind.window}}" -name = "window" -description = "window/editor pane manipulation-related commands" +doc.name = "window" +doc.description = "window/editor pane manipulation-related commands" key = "tab w" command = "master-key.prefix" [[bind]] default = "{{bind.window}}" -name = "vert/horz" +doc.name = "vert/horz" key = "tab w r" -description = "Toggle between horizontal and vertical layouts" +doc.description = "Toggle between horizontal and vertical layouts" command = "workbench.action.toggleEditorGroupLayout" [[bind]] default = "{{bind.window}}" -name = "next window" -combinedName = "next/previous window" -description = "move to next window" -combinedDescription = "move to next/prev window" +doc.name = "next window" +doc.combinedName = "next/previous window" +doc.description = "move to next window" +doc.combinedDescription = "move to next/prev window" key = "tab ]" -combinedKey = "]/[" +doc.combinedKey = "]/[" command = "workbench.action.focusNextGroup" [[bind]] default = "{{bind.window}}" -name = "prev window" -combinedName = "next/previous window" -description = "move to previous window" +doc.name = "prev window" +doc.combinedName = "next/previous window" +doc.description = "move to previous window" key = "tab [" command = "workbench.action.focusPreviousGroup" [[bind]] default = "{{bind.window}}" -name = "move →" -combinedName = "move →/←" -combinedDescription = "move editor to window left/right" -combinedKey = "l/h" -description = "move editor to window to left" +doc.name = "move →" +doc.combinedName = "move →/←" +doc.combinedDescription = "move editor to window left/right" +doc.combinedKey = "l/h" +doc.description = "move editor to window to left" key = "tab w l" command = "workbench.action.moveEditorToRightGroup" [[bind]] default = "{{bind.window}}" -name = "←" -combinedName = "move →/←" -description = "move editor to window to left" +doc.name = "←" +doc.combinedName = "move →/←" +doc.description = "move editor to window to left" key = "tab w h" command = "workbench.action.moveEditorToLeftGroup" [[bind]] default = "{{bind.window}}" -name = "↓" -combinedName = "move ↓/↑" -combinedDescription = "move editor to window above/below" -combinedKey = "j/k" -description = "move editor to window below" +doc.name = "↓" +doc.combinedName = "move ↓/↑" +doc.combinedDescription = "move editor to window above/below" +doc.combinedKey = "j/k" +doc.description = "move editor to window below" key = "tab w j" command = "workbench.action.moveEditorToBelowGroup" [[bind]] default = "{{bind.window}}" -name = "↑" -combinedName = "move ↓/↑" -description = "move editor to window above" +doc.name = "↑" +doc.combinedName = "move ↓/↑" +doc.description = "move editor to window above" key = "tab w k" command = "workbench.action.moveEditorToAboveGroup" [[bind]] default = "{{bind.window}}" -name = "split editor..." -description = "split editor to in a given direction" +doc.name = "split editor..." +doc.description = "split editor to in a given direction" key = "tab w s" command = "master-key.prefix" [[bind]] default = "{{bind.window}}" -name = "move →" -combinedName = "split →/←" -combinedDescription = "move editor to window left/right" -combinedKey = "l/h" -description = "split editor to window to left" +doc.name = "move →" +doc.combinedName = "split →/←" +doc.combinedDescription = "move editor to window left/right" +doc.combinedKey = "l/h" +doc.description = "split editor to window to left" key = "tab w s l" command = "workbench.action.splitEditorRight" [[bind]] default = "{{bind.window}}" -name = "←" -combinedName = "split →/←" -description = "split editor to window to left" +doc.name = "←" +doc.combinedName = "split →/←" +doc.description = "split editor to window to left" key = "tab w s h" command = "workbench.action.splitEditorLeft" [[bind]] default = "{{bind.window}}" -name = "↓" -combinedName = "split ↓/↑" -combinedDescription = "split editor to window above/below" -combinedKey = "j/k" -description = "split editor to window below" +doc.name = "↓" +doc.combinedName = "split ↓/↑" +doc.combinedDescription = "split editor to window above/below" +doc.combinedKey = "j/k" +doc.description = "split editor to window below" key = "tab w s j" command = "workbench.action.splitEditorDown" [[bind]] default = "{{bind.window}}" -name = "↑" -combinedName = "split ↓/↑" -combinedDescription = "split editor to window above/below" -combinedKey = "j/k" -description = "split editor to window below" +doc.name = "↑" +doc.combinedName = "split ↓/↑" +doc.combinedDescription = "split editor to window above/below" +doc.combinedKey = "j/k" +doc.description = "split editor to window below" key = "tab w s k" command = "workbench.action.splitEditorUp" [[bind]] default = "{{bind.window}}" -name = "close pane" -description = "close the given group of editors" +doc.name = "close pane" +doc.description = "close the given group of editors" key = "tab w x" command = "workbench.action.closeEditorsInGroup" [[bind]] default = "{{bind.window}}" -name = "max" -description = "minimize size of all other windows" +doc.name = "max" +doc.description = "minimize size of all other windows" key = "tab w shift+m" command = "workbench.action.minimizeOtherEditors" [[bind]] default = "{{bind.window}}" -name = "equal" -description = "equalize size of all windows" +doc.name = "equal" +doc.description = "equalize size of all windows" key = "tab w =" command = "workbench.action.evenEditorWidths" [[bind]] default = "{{bind.window}}" -name = "curs. win top" -description = "center window so that primary cursor is at the top" +doc.name = "curs. win top" +doc.description = "center window so that primary cursor is at the top" key = "tab k" -combinedName = "center window top/bottom" -combinedDescription = "center window so that primary cursor is at the top/bottom" -combinedKey = "k/j" +doc.combinedName = "center window top/bottom" +doc.combinedDescription = "center window so that primary cursor is at the top/bottom" +doc.combinedKey = "k/j" command = "selection-utilities.revealActive" args.at = "top" [[bind]] default = "{{bind.window}}" -name = "curs. win bot" -combinedName = "center window top/bottom" -description = "center window so that primary cursor is at the bottom" +doc.name = "curs. win bot" +doc.combinedName = "center window top/bottom" +doc.description = "center window so that primary cursor is at the bottom" key = "tab j" command = "selection-utilities.revealActive" args.at = "bottom" @@ -2836,62 +2836,62 @@ args.at = "bottom" [[bind]] default = "{{bind.util}}" -name = "breakpt." -combinedName = "breakpt / debug..." -combinedKey = "shift+b/b" -description = "toggle debug breakpoint" -combinedDescription = "toggle debug breakpoint / debug related commands..." +doc.name = "breakpt." +doc.combinedName = "breakpt / debug..." +doc.combinedKey = "shift+b/b" +doc.description = "toggle debug breakpoint" +doc.combinedDescription = "toggle debug breakpoint / debug related commands..." key = "tab shift+b" command = "editor.debug.action.toggleBreakpoint" [[bind]] default = "{{bind.util}}" -name = "debug..." -combinedName = "breakpt / debug..." -description = "assorted debugging actions" +doc.name = "debug..." +doc.combinedName = "breakpt / debug..." +doc.description = "assorted debugging actions" key = "tab b" command = "master-key.prefix" [[bind]] default = "{{bind.util}}" -name = "cond. break" -description = "conditional breakpoint" +doc.name = "cond. break" +doc.description = "conditional breakpoint" key = "tab b shift+c" command = "editor.debug.action.conditionalBreakpoint" [[bind]] default = "{{bind.util}}" -name = "start" -description = "start debugging" +doc.name = "start" +doc.description = "start debugging" key = "tab b r" command = "workbench.action.debug.start" [[bind]] default = "{{bind.util}}" -name = "continue" -description = "continue debugging" +doc.name = "continue" +doc.description = "continue debugging" key = "tab b c" command = "workbench.action.debug.continue" [[bind]] default = "{{bind.util}}" -name = "next" -description = "debug: step over next line" +doc.name = "next" +doc.description = "debug: step over next line" key = "tab b j" command = "workbench.action.debug.stepOver" [[bind]] default = "{{bind.util}}" -name = "into" -description = "debug: step into next line" +doc.name = "into" +doc.description = "debug: step into next line" key = "tab b i" command = "workbench.action.debug.stepInto" [[bind]] default = "{{bind.util}}" -name = "out" -description = "debug: step out" +doc.name = "out" +doc.description = "debug: step out" key = "tab b o" command = "workbench.action.debug.stepOut" @@ -2907,12 +2907,12 @@ command = "workbench.action.debug.stepOut" [[define.bind]] id = "edit_select_edit" mode = "selectedit" -kind = "motion" +doc.kind = "motion" [[bind]] default = "{{bind.edit_select_edit}}" -name = "select-edit" -description = """ +doc.name = "select-edit" +doc.description = """ Enter a mode where you can edit and manipulate (possibly multiple) selections. """ key = "'" @@ -2923,11 +2923,11 @@ mode = "normal" [[bind]] default = "{{bind.edit_select_edit}}" key = "shift+'" -combinedName = "rm cursors" -combinedKey = "shift/ctrl+'" -combinedDescription = "Delete all selections and return to normal (multiple key variants)" -name = "del. cursors" -description = "Delete all selections and return to normal" +doc.combinedName = "rm cursors" +doc.combinedKey = "shift/ctrl+'" +doc.combinedDescription = "Delete all selections and return to normal (multiple key variants)" +doc.name = "del. cursors" +doc.description = "Delete all selections and return to normal" command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] mode = '{{all_modes_but(["selectedit", "normal"]}}' @@ -2936,117 +2936,117 @@ mode = '{{all_modes_but(["selectedit", "normal"]}}' default = "{{bind.edit_select_edit}}" key = "ctrl+'" mode = '{{all_modes_but(["insert", "selectedit", "normal"]}}' -name = "rm cursors" -combinedName = "rm cursors" -description = "Delete all selections and return to normal" +doc.name = "rm cursors" +doc.combinedName = "rm cursors" +doc.description = "Delete all selections and return to normal" command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] [[bind]] default = "{{bind.edit_select_edit}}" -name = 'normal' -description = "return to normal mode" +doc.name = 'normal' +doc.description = "return to normal mode" key = "'" command = "master-key.enterNormal" [[bind]] default = "{{bind.edit_select_edit}}" -name = "add →" -combinedName = "add →/←" -description = "add cursor at the next match to the primary cursor's text" -combinedDescription = "add cursor at the next/previous match to the primary cursor's text" +doc.name = "add →" +doc.combinedName = "add →/←" +doc.description = "add cursor at the next match to the primary cursor's text" +doc.combinedDescription = "add cursor at the next/previous match to the primary cursor's text" key = "l" -combinedKey = "l/h" +doc.combinedKey = "l/h" repeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] default = "{{bind.edit_select_edit}}" -name = "add ←" -combinedName = "add →/←" -description = "add cursor at the previous match to the primary cursor's text" +doc.name = "add ←" +doc.combinedName = "add →/←" +doc.description = "add cursor at the previous match to the primary cursor's text" key = "h" command = "selection-utilities.addPrev" repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" -name = "skip →" -combinedName = "skip →/←" -description = "move primary cursor to the next match of the primary cursor's text" -combinedDescription = "move primary cursor to the next/previous match of the primary cursor's text" +doc.name = "skip →" +doc.combinedName = "skip →/←" +doc.description = "move primary cursor to the next match of the primary cursor's text" +doc.combinedDescription = "move primary cursor to the next/previous match of the primary cursor's text" key = "shift+l" -combinedKey = "shift+l/h" +doc.combinedKey = "shift+l/h" command = "selection-utilities.skipNext" repeat = "{{count}}" [[bind]] default = "{{bind.edit_select_edit}}" -name = "skip ←" -combinedName = "skip →/←" -description = "move primary cursor to the previous match of the primary cursor's text" +doc.name = "skip ←" +doc.combinedName = "skip →/←" +doc.description = "move primary cursor to the previous match of the primary cursor's text" key = "shift+h" command = "selection-utilities.skipPrev" repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" -name = "align ←" -description = "align selections left" +doc.name = "align ←" +doc.description = "align selections left" key = "=" command = "selection-utilities.alignSelectionsLeft" [[bind]] default = "{{bind.edit_select_edit}}" -name = "align →" -description = "align selections right" +doc.name = "align →" +doc.description = "align selections right" key = "shift+=" command = "selection-utilities.alignSelectionsRight" [[bind]] default = "{{bind.edit_select_edit}}" -name = "→ sel" -combinedName = "→/← sel" -description = """ +doc.name = "→ sel" +doc.combinedName = "→/← sel" +doc.description = """ make the next selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections """ -combinedDescription = """ +doc.combinedDescription = """ make the next/previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections """ key = "j" -combinedKey = "j/l" +doc.combinedKey = "j/l" command = "selection-utilities.movePrimaryRight" repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" -name = "← sel" -combinedName = "→/← sel" -description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" +doc.name = "← sel" +doc.combinedName = "→/← sel" +doc.description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" key = "k" command = "selection-utilities.movePrimaryLeft" repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" -name = "insert ↑" -combinedName = "insert ↑/↓" -description = """ +doc.name = "insert ↑" +doc.combinedName = "insert ↑/↓" +doc.description = """ insert cursor on line above """ -combinedDescription = "insert cursor on line above/below" +doc.combinedDescription = "insert cursor on line above/below" key = "shift+k" -combinedKey = "shift+k/j" +doc.combinedKey = "shift+k/j" command = "editor.action.insertCursorAbove" repeat = "{{count}}" [[bind]] default = "{{bind.edit_select_edit}}" -name = "insert sel ↓" -combinedName = "insert ↑/↓" -description = """ +doc.name = "insert sel ↓" +doc.combinedName = "insert ↑/↓" +doc.description = """ insert cursor on line below """ key = "shift+j" @@ -3055,10 +3055,10 @@ repeat = "{{count-1}}" [[bind]] default = "{{bind.edit_select_edit}}" -name = "del. primary" -combinedName = "del. primary/others" -description = "remove the primary selection" -combinedDescription = """ +doc.name = "del. primary" +doc.combinedName = "del. primary/others" +doc.description = "remove the primary selection" +doc.combinedDescription = """ Remove either the primary selection or all selections. Return to normal mode if all selections are deleted. """ @@ -3068,15 +3068,15 @@ repeat = "{{count-1}}" [[bind]] default = "{{bind.edit_select_edit}}" -name = 'del. others' -description = "delete all other cursors but the primary selection" +doc.name = 'del. others' +doc.description = "delete all other cursors but the primary selection" key = "shift+d" command = "removeSecondaryCursors" [[bind]] default = "{{bind.edit_select_edit}}" -name = "save sel" -description = """ +doc.name = "save sel" +doc.description = """ save all selections to the default register. Use a count to specify an alternate register """ @@ -3090,8 +3090,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_select_edit}}" -name = "load sel" -description = """ +doc.name = "load sel" +doc.description = """ load previously saved selections in the default register. Use a count to specify an alternate register """ @@ -3103,8 +3103,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_select_edit}}" -name = "exchange sel" -description = """ +doc.name = "exchange sel" +doc.description = """ exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. """ key = "x" @@ -3116,8 +3116,8 @@ args.commands = [ [[bind]] default = "{{bind.edit_select_edit}}" -name = "rem saved sel" -description = """ +doc.name = "rem saved sel" +doc.description = """ remove the most recently saved selection from the list of saved selections """ command = "runCommands" @@ -3130,16 +3130,16 @@ args.commands = [ [[bind]] default = "{{bind.edit_select_edit}}" key = "shift+enter" -name = "split sel" -description = """ +doc.name = "split sel" +doc.description = """ split selection into multiple selections by new line charactesr """ command = "selection-utilities.splitByNewline" [[bind]] default = "{{bind.edit_select_edit}}" -name = "sel all" -description = """ +doc.name = "sel all" +doc.description = """ create a selection for every match of the current word (or selection) """ key = "shift+8" @@ -3147,8 +3147,8 @@ command = "editor.action.selectHighlights" [[bind]] default = "{{bind.edit_select_edit}}" -name = "character" -description = "split by a given character" +doc.name = "character" +doc.description = "split by a given character" key = "s" command = "runCommands" @@ -3162,15 +3162,15 @@ args.text = "{{captured}}" [[bind]] default = "{{bind.edit_select_edit}}" -name = "string" -description = "split by a given string" +doc.name = "string" +doc.description = "split by a given string" key = "shift+s" command = "selection-utilities.splitBy" [[bind]] default = "{{bind.edit_select_edit}}" -name = "include" -description = """ +doc.name = "include" +doc.description = """ Include all selections that contain a given marker """ key = "f" @@ -3178,8 +3178,8 @@ command = "selection-utilities.includeBy" [[bind]] default = "{{bind.edit_select_edit}}" -name = "exclude" -description = """ +doc.name = "exclude" +doc.description = """ Exclude all selections that contain a given marker """ key = "shift+f" @@ -3187,61 +3187,61 @@ command = "selection-utilities.excludeBy" [[bind]] default = "{{bind.edit_select_edit}}" -name = "create" -description = "create selections of given string scoped to the current selections" +doc.name = "create" +doc.description = "create selections of given string scoped to the current selections" key = "/" command = "selection-utilities.createBy" [[bind]] default = "{{bind.edit_select_edit}}" -name = "regex" -description = "operations by regex rather than string" +doc.name = "regex" +doc.description = "operations by regex rather than string" key = "r" command = "master-key.prefix" [[bind]] default = "{{bind.edit_select_edit}}" -name = "split" -description = "split by a given regular expression" +doc.name = "split" +doc.description = "split by a given regular expression" key = "r shift+s" command = "selection-utilities.splitByRegex" [[bind]] default = "{{bind.edit_select_edit}}" -name = "create" -description = "create selections of given regular expression scoped to the current selections" +doc.name = "create" +doc.description = "create selections of given regular expression scoped to the current selections" key = "r /" command = "selection-utilities.createByRegex" [[bind]] default = "{{bind.edit_select_edit}}" -name = "include" -description = "Include all selections that contain a given regular expression" +doc.name = "include" +doc.description = "Include all selections that contain a given regular expression" key = "r f" command = "selection-utilities.includeByRegex" [[bind]] default = "{{bind.edit_select_edit}}" -name = "exclude" -description = "Exclude all selections that contain a given regular expression" +doc.name = "exclude" +doc.description = "Exclude all selections that contain a given regular expression" key = "r shift+f" command = "selection-utilities.excludeByRegex" [[bind]] default = "{{bind.edit_select_edit}}" key = "o" -name = "active to front" -combinedKey = "o/shift+o" -combinedName = "active to start/end" -combinedDescription = "move cursor to start/end of selection" -description = "move cursor to start of selection" +doc.name = "active to front" +doc.combinedKey = "o/shift+o" +doc.combinedName = "active to start/end" +doc.combinedDescription = "move cursor to start/end of selection" +doc.description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_select_edit}}" -name = "active to end" -combinedName = "active to start/end" -description = "move cursor to back of selection" +doc.name = "active to end" +doc.combinedName = "active to start/end" +doc.description = "move cursor to back of selection" key = "shift+o" command = "selection-utilities.activeAtStart" @@ -3274,7 +3274,7 @@ command = "selection-utilities.activeAtStart" ">".after = ">" [[mode]] -name = "syminsert" +doc.name = "syminsert" highlight = "Highlight" cursorShape = "BlockOutline" @@ -3286,32 +3286,32 @@ args.followCursor = true [[define.bind]] id = "edit_action_symmetric" -kind = "action" +doc.kind = "action" mode = "syminsert" [[define.bind]] id = "edit_motion_symmetric" -kind = "motion" +doc.kind = "motion" mode = "syminsert" [[bind]] default = "{{bind.edit_action_symmetric}}" -name = "sym insert mode" +doc.name = "sym insert mode" priority = 1 -description = """ +doc.description = """ In this mode all commands and character insertions happen at both ends of the selection """ mode = "normal" key = "space shift+i" -combinedName = "sym insert (mode)" +doc.combinedName = "sym insert (mode)" command = "master-key.setMode" args.value = "syminsert" [[bind]] default = "{{bind.edit_action_symmetric}}" -name = "Normal" -description = "Return to normal model" +doc.name = "Normal" +doc.description = "Return to normal model" key = "enter" command = "master-key.setMode" mode = "syminsert" @@ -3320,19 +3320,19 @@ mode = "syminsert" default = "{{bind.edit_action_symmetric}}" foreach.key = ["{{keys(`[a-z]`)}}"] foreach.modifier = ["shift+", ""] -name = "" -description = "this key is ignored and has no associated command in syminsert mode" +doc.name = "" +doc.description = "this key is ignored and has no associated command in syminsert mode" key = "{{modifier}}{{key}}" command = "master-key.ignore" mode = "syminsert" -hideInDocs = true -hideInPalette = true +doc.hideInDocs = true +doc.hideInPalette = true [[bind]] -name = "esc. char" +doc.name = "esc. char" default = "{{bind.edit_action_symmetric}}" key = "\\" -description = "Insert escaped character" +doc.description = "Insert escaped character" command = "runCommands" [[bind.args.commands]] @@ -3347,9 +3347,9 @@ args.followCursor = true [[bind]] default = "{{bind.edit_action_symmetric}}" -name = "delete" +doc.name = "delete" key = "x" -description = """ +doc.description = """ delete the first and last adjacent character when cursor is at end of selection and delete the first and last character *in* the selection when cursor is at the start of the selection @@ -3361,8 +3361,8 @@ args.followCursor = true [[bind]] default = "{{bind.edit_motion_symmetric}}" key = "l" -name = "sel →" -description = "shrink/grow selections in direction that's rightwards from cursor" +doc.name = "sel →" +doc.description = "shrink/grow selections in direction that's rightwards from cursor" command = "selection-utilities.adjustSelections" args.dir = "forward" args.count = "{{count}}" @@ -3370,8 +3370,8 @@ args.count = "{{count}}" [[bind]] default = "{{bind.edit_motion_symmetric}}" key = "h" -name = "sel ←" -description = "shrink/grow selections in direction that's leftwards from cursor" +doc.name = "sel ←" +doc.description = "shrink/grow selections in direction that's leftwards from cursor" command = "selection-utilities.adjustSelections" args.dir = "backward" args.count = "{{count}}" @@ -3379,38 +3379,38 @@ args.count = "{{count}}" [[bind]] default = "{{bind.edit_motion_symmetric}}" key = "o" -name = "active to front" -combinedKey = "o/shift+o" -combinedName = "active to start/end" -combinedDescription = "move cursor to start/end of selection" -description = "move cursor to start of selection" +doc.name = "active to front" +doc.combinedKey = "o/shift+o" +doc.combinedName = "active to start/end" +doc.combinedDescription = "move cursor to start/end of selection" +doc.description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_motion_symmetric}}" -name = "active to end" -combinedName = "active to start/end" -description = "move cursor to back of selection" +doc.name = "active to end" +doc.combinedName = "active to start/end" +doc.description = "move cursor to back of selection" key = "shift+o" command = "selection-utilities.activeAtStart" [[bind]] default = "{{bind.edit_action_symmetric}}" -name = "undo" +doc.name = "undo" key = "u" command = "undo" [[bind]] default = "{{bind.edit_action_symmetric}}" -name = "redo" +doc.name = "redo" key = "shift+u" command = "redo" [[bind]] default = "{{bind.edit_motion_symmetric}}" key = "v" -name = "shrink selection" -description = """ +doc.name = "shrink selection" +doc.description = """ reduce all selections to length zero and return to normal mode """ command = "runCommands" diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 498e47e4..0e6c0ee3 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -2,27 +2,23 @@ #[allow(unused_imports)] use log::info; -use rhai::Dynamic; -use std::collections::HashMap; -use std::collections::VecDeque; -use std::convert::identity; - -use indexmap::IndexMap; use serde::{Deserialize, Serialize}; -use serde_wasm_bindgen; +use std::collections::BTreeMap; +use std::convert::identity; use toml::Spanned; -use wasm_bindgen::JsValue; use wasm_bindgen::prelude::*; +pub mod command; mod foreach; pub mod validation; -use crate::bind::foreach::expand_keys; +use crate::bind::command::{Command, regularize_commands}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{Error, ErrorContext, Result, ResultVec, constrain, reserved, unexpected}; +use crate::error::{Result, ResultVec, reserved, unexpected}; +use crate::expression::Scope; +use crate::expression::value::{Expanding, TypedValue, Value}; use crate::util::{Merging, Plural, Required, Resolving}; -use crate::value::{Expanding, TypedValue, Value}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; @@ -41,213 +37,170 @@ fn span_plural_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Plural::Zero); } -/** - * @bindingField bind - * @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` - * - * **Example** - * - * ```toml - * [[bind]] - * name = "left" - * key = "h" - * mode = "normal" - * command = "cursorLeft" - * ``` - * The `bind` element has two categories of fields: functional and documenting. - * - * ## Functional Fields - * - * The functional fields determine what the keybinding does. Required fields are marked with - * a `*`. - * - */ +// +// ================ `[[bind]]` parsing ================ +// + +/// @bindingField bind +/// @description an actual keybinding; extends the schema used by VSCode's `keybindings.json` +/// +/// **Example** +/// +/// ```toml +/// [[bind]] +/// doc.name = "←" +/// key = "h" +/// mode = "normal" +/// command = "cursorLeft" +/// ``` +/// In the below field descriptions note that: +/// +/// - ❗ denotes a required field. +/// - ⚡ denotes that a field can include runtime [expressions](/expressions/index) +/// #[derive(Deserialize, Clone, Debug)] pub struct BindingInput { - // should only be `Some` in context of `Define(Input)` + // implementation detail of `BindingInput`: this field should only be `Some` when used + // as a part of an entry to `Define`. It is removed downstream using `without_id`. pub(crate) id: Option>, - /** - * @forBindingField bind - * - * - `command`*: A string denoting the command to execute. This is a command - * defined by VSCode or an extension thereof. - * See [finding commands](#finding-commands). This field has special - * behavior when set to`runCommands` - * (see [running multiple commands](#running-multiple-commands)). - */ + + /// @forBindingField bind + /// + /// - ❗`command`: A string denoting the command to execute. This is a command defined by + /// VSCode or an extension thereof. See [finding commands](#finding-commands). This + /// field has special behavior when set to`runCommands` (see + /// [running multiple commands](#running-multiple-commands)). #[serde(default = "span_required_default")] pub command: Spanned>>, - /** - * @forBindingField bind - * - * - `args`: The arguments to directly pass to the `command`, these are static - * values. - */ + /// @forBindingField bind + /// + /// - ⚡ `args`: The arguments to directly pass to `command`. Args may include + /// runtime evaluated [expressions](/expressions/index). #[serde(default)] pub args: Option>, - /** - * @forBindingField bind - * - * - `key`*: the - * [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that - * triggers `command`. - */ + /// @forBindingField bind + /// + /// - ❗`key`: the + /// [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that + /// triggers `command`. #[serde(default = "span_required_default")] pub key: Spanned>, - /** - * @forBindingField bind - * - * - `when`: A [when - * clause](https://code.visualstudio.com/api/references/when-clause-contexts) - * context under which the binding will be active. Also see Master Key's - * [available contexts](#available-contexts) - */ + + /// @forBindingField bind + /// + /// - `when`: A [when clause](https://code.visualstudio.com/api/references/when-clause-contexts) + /// context under which the binding will be active. Also see Master Key's + /// [available contexts](#available-when-contexts) pub when: Option>>, - /** - * @forBindingField bind - * - * - `mode`: The mode during which the binding will be active. The default mode is - * used when this field is not specified (either directly or via the `defaults` - * field). You can also specify multiple modes as an array of strings. To specify - * a binding that is applied in all modes use "{{all_modes()}}". - */ + /// @forBindingField bind + /// + /// - `mode`: The mode during which the binding will be active. The default mode is + /// used when this field is not specified (either directly or via the `defaults` + /// field). You can also make use of an [expression](/expressions/index) + /// that will be evaluated while the bindings are being parsed. There are two + /// available functions of use here: + /// [`all_modes`](/expressions/functions#all_modes) and + /// [`all_modes_but`](/expressions/functions#all_modes_but) #[serde(default = "default_mode")] pub mode: Spanned>>, - /** - * @forBindingField bind - * - * - `priority`: The ordering of the keybinding relative to others; determines which - * bindings take precedence. Defaults to 0. - */ + /// @forBindingField bind + /// + /// - `priority`: The ordering of the keybinding relative to others; determines which + /// bindings take precedence. Defaults to 0. #[serde(default)] pub priority: Option>>, - /** - * @forBindingField bind - * - * - `default`: the default values to use for fields, specified as - * string of the form `{{bind.[name]}}`. - * See [`define`](/bindings/define) for more details. - */ + /// @forBindingField bind + /// + /// - `default`: the default values to use for fields, specified as + /// string of the form `{{bind.[name]}}`. + /// See [`define`](/bindings/define) for more details. #[serde(default)] pub default: Option>, - /** - * @forBindingField bind - * - * - `foreach`: Allows parametric definition of multiple keybindings, see - * [`foreach` clauses](#foreach-clauses). - */ + /// @forBindingField bind + /// + /// - `foreach`: Allows parametric definition of multiple keybindings, see + /// [`foreach` clauses](#foreach-clauses). #[serde(default)] - pub foreach: Option>>>, - - /** - * @forBindingField bind - * - * - `prefixes`: (array of strings or the string - * {{all_prefixes}}). Determines one or more *unresolved* key - * sequences that can have occurred before typing this key. See - * [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. - * no prefix is allowed). This can be set to {{all_prefixes}}, - * if you wish to allow the key binding to work regardless of any unresolved key - * sequence that has been pressed (e.g. this is used for the "escape" key binding - * in Larkin). - */ + pub foreach: Option>>>, + + /// @forBindingField bind + /// + /// - `prefixes`: array of strings or an expression of producing such an array. + /// (see also [`all_prefixes`](expressions/functions#all_prefixes). + /// The prefixes determine one or more *unresolved* key + /// sequences that can have occurred before typing this key. See + /// [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. + /// no prefix is allowed). Setting this to {{all_prefixes}}, + /// will allow a key binding to work regardless of any unresolved key + /// sequence that has been pressed: this is how `esc` is defined to work + /// in Larkin. #[serde(default = "span_plural_default")] pub prefixes: Spanned>>, - /** - * @forBindingField bind - * - * - `finalKey`: (boolean, default=true) Whether this key should clear any transient - * state associated with the pending keybinding prefix. See - * [`master-key.prefix`](/commands/prefix) for details. - */ + /// @forBindingField bind + /// + /// - `finalKey`: (boolean, default=true) Whether this key should clear any transient + /// state associated with the pending keybinding prefix. See + /// [`master-key.prefix`](/commands/prefix) for details. #[serde(default)] pub finalKey: Option>>, - /** - * @forBindingField bind - * - * **TODO**: update docs, and make it possible to be a number or a string - * - * - `repeat`: This is an [expression](/expressions/index). It is expected - * to evaluate to the number of times to repeat the command. Defaults to zero: one - * repeat means the command is run twice. - * - `command` will be repeated the given - * number of times. - */ + /// @forBindingField bind + /// + /// - ⚡ `repeat`: The number of times to repeat the command; this can be a runtime + /// [expression](/expressions/index). This defaults to zero: one repeat means the + /// command is run twice. repeat: Option>>, - /** - * @forBindingField bind - * @order 10 - * - * ## Documenting Fields - * - * The documenting fields determine how the keybinding is documented. They are all - * optional. - * - * - `name`: A very description for the command; this must fit in the visual - * documentation so it shouldn't be much longer than five characters for most - * keys. Favor unicode symbols such as → and ← over text. - */ - #[serde(default)] - pub name: Option>>, - - /** - * @forBindingField bind - * @order 10 - * - * - `description`: A longer description of what the command does. Shouldn't be much - * longer than a single sentence for most keys. Save more detailed descriptions - * for the literate comments. - */ - #[serde(default)] - pub description: Option>>, - /** - * @forBindingField bind - * @order 10 - * - * - `hideInPalette/hideInDocs`: whether to show the keys in the popup suggestions - * and the documentation. These both default to false. - */ - #[serde(default)] - pub hideInPalette: Option>>, - #[serde(default)] - pub hideInDocs: Option>>, - - /** - * @forBindingField bind - * @order 10 - * - * - `combinedName/combinedKey/combinedDescription`: in the suggestion palette and - * textual documentation, keys that have the same `combinedName` will be - * represented as single entry, using the `combinedKey` and `combinedDescription` - * instead of `key` and `description`. The `combinedKey` for a multi-key sequence - * should only include the suffix key. All but the first key's `combinedKey` and - * `combinedDescription` are ignored. - */ - #[serde(default)] - pub combinedName: Option>>, - #[serde(default)] - pub combinedKey: Option>>, - #[serde(default)] - pub combinedDescription: Option>>, - - /** - * @forBindingField bind - * @order 10 - * - * - `kind`: The broad cagegory of commands this binding falls under. There should - * be no more than 4-5 of these. Each `kind` here should have a corresponding - * entry in the top-level `kind` array. - */ - #[serde(default)] - pub kind: Option>>, + /// @forBindingField bind + /// + /// - `doc`: Documentation for this keybinding, none of the fields of this object + /// impact the behavior of the keybinding, only the interactive documentation + /// features describing keybindings. + doc: Option, } +/// @forBindingField bind +/// @order 20 +/// +/// ## Finding Commands +/// +/// You can find commands in a few ways: +/// +/// - Find command you want to use from the command palette, and click on the gear (`⚙︎`) +/// symbol to copy the command string to your clipboard +/// - Review the [list of built-in +/// commands](https://code.visualstudio.com/api/references/commands/index) +/// - Run the command `Preferences: Open Default Keyboard Shortcuts (JSON)` to get a list of +/// built-in commands and extension commands already associated with a keybinding +/// +/// Furthermore, you can also use: +/// +/// - [Master Key Commands](/commands/index) +/// - [Selection Utility +/// Commands](https://haberdashpi.github.io/vscode-selection-utilities/) +/// +/// Selection Utilities is a complimentary extension used extensively by the `Larkin` +/// preset. +/// +/// ## Available `when` Contexts +/// +/// Each keybinding can make use of any context defined in VSCode across any extension. +/// Master Key adds the follow contexts: +/// +/// - All variables available to an [expression](/expressions/index), prefixed with +/// `master-key.` +/// - `master-key.keybindingPaletteBindingMode`: true when the suggestion palette accepts +/// keybinding key presses, false it accepts a string to search the descriptions of said +/// keybindings +/// - `master-key.keybindingPaletteOpen`: true when the suggestion palette is open +/// + impl BindingInput { + // removes `id` field, this field is an implementation detail and should only be present + // as a part of a `Define` object. pub(crate) fn without_id(&self) -> Self { return BindingInput { id: None, @@ -262,14 +215,7 @@ impl BindingInput { prefixes: self.prefixes.clone(), finalKey: self.finalKey.clone(), repeat: self.repeat.clone(), - name: self.name.clone(), - description: self.description.clone(), - hideInPalette: self.hideInPalette.clone(), - hideInDocs: self.hideInDocs.clone(), - combinedName: self.combinedName.clone(), - combinedKey: self.combinedKey.clone(), - combinedDescription: self.combinedDescription.clone(), - kind: self.kind.clone(), + doc: self.doc.clone(), }; } } @@ -284,7 +230,6 @@ impl Merging for BindingInput { command: self.command.coalesce(y.command), args: self.args.merge(y.args), key: self.key.coalesce(y.key), - kind: self.kind.coalesce(y.kind), when: self.when.coalesce(y.when), mode: self.mode.coalesce(y.mode), priority: self.priority.coalesce(y.priority), @@ -293,316 +238,11 @@ impl Merging for BindingInput { prefixes: self.prefixes.coalesce(y.prefixes), finalKey: self.finalKey.coalesce(y.finalKey), repeat: self.repeat.coalesce(y.repeat), - name: self.name.coalesce(y.name), - description: self.description.coalesce(y.description), - hideInPalette: self.hideInPalette.coalesce(y.hideInPalette), - hideInDocs: self.hideInDocs.coalesce(y.hideInDocs), - combinedName: self.combinedName.coalesce(y.combinedName), - combinedKey: self.combinedKey.coalesce(y.combinedKey), - combinedDescription: self.combinedDescription.coalesce(y.combinedDescription), - } - } -} - -#[derive(Deserialize, Clone, Debug)] -pub struct CommandInput { - // should only be `Some` in context of `Define(Input)` - pub(crate) id: Option>>, - pub command: Spanned>>, - pub args: Option>, -} - -impl Expanding for CommandInput { - fn is_constant(&self) -> bool { - if self.command.is_constant() { - return false; - } - if self.args.is_constant() { - return false; - } - return true; - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - let mut errors = Vec::new(); - let result = CommandInput { - id: self.id, - command: self.command.map_expressions(f).unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) - }), - args: self.args.map_expressions(f).unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - None - }), - }; - if errors.len() > 0 { - return Err(errors.into()); - } else { - return Ok(result); + doc: self.doc.merge(y.doc), } } } -impl CommandInput { - pub(crate) fn without_id(&self) -> Self { - return CommandInput { - id: None, - command: self.command.clone(), - args: self.args.clone(), - }; - } -} - -impl From for Value { - fn from(value: CommandInput) -> Self { - let mut entries = IndexMap::new(); - let command = value.command.into_inner(); - if let Required::Value(command_value) = command { - entries.insert("command".to_string(), command_value.into()); - } - if let Some(arg_value) = value.args { - entries.insert("args".to_string(), arg_value.into_inner()); - } - return Value::Table(entries); - } -} - -#[wasm_bindgen(getter_with_clone)] -#[derive(Clone, Debug, Serialize)] -pub struct Command { - pub command: String, - pub(crate) args: Value, -} - -// TODO: here is where we would want to invoke rhai to resolve any outstanding expressions - -#[wasm_bindgen] -pub struct Scope { - asts: HashMap, - engine: rhai::Engine, - state: rhai::Scope<'static>, - queues: HashMap>, -} - -// TODO: we'll need to define `CustomType` on `Value` and `Command` -#[wasm_bindgen] -impl Scope { - // TODO: incorporate command queues - fn expand(&mut self, obj: &T) -> ResultVec - where - T: Expanding + Clone, - { - for (k, v) in self.queues.iter() { - // TODO: tell engine how to handle dequeues - // TODO: I don't love that we have to copy the queue for every evaluation - // this will have to be fixed to avoid ridiculous amounts of copying - // per command run - - // PLAN: make queue type a CustomType and track it in `state` instead of - // in `queues`. - self.state.set_or_push(k, v.clone()); - } - return Ok(obj.clone().map_expressions(&mut |expr| { - let ast = &self.asts[&expr]; - let result = self.engine.eval_ast_with_scope(&mut self.state, &ast); - let value: rhai::Dynamic = match result { - Err(x) => Err(Error::ExpressionEval(format!("{}", x)))?, - Ok(x) => x, - }; - let result_value: Value = value.clone().try_into()?; - return Ok(result_value); - })?); - } - - pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { - x.clone().map_expressions(&mut |expr| { - let ast = self.engine.compile_expression(expr.clone())?; - self.asts.insert(expr.clone(), ast); - return Ok(Value::Expression(expr)); - })?; - return Ok(()); - } - - #[wasm_bindgen(constructor)] - pub fn new() -> Scope { - let engine = rhai::Engine::new(); - - return Scope { - asts: HashMap::new(), - engine: engine, - state: rhai::Scope::new(), - queues: HashMap::new(), - }; - } - - pub fn set(&mut self, name: String, value: JsValue) -> Result<()> { - let toml: toml::Value = match serde_wasm_bindgen::from_value(value) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, - Ok(x) => x, - }; - let val: Value = toml.try_into()?; - let val: Dynamic = val.into(); - self.state.set_or_push(&name, val); - return Ok(()); - } - - pub fn unset(&mut self, name: String) -> Result<()> { - return Ok(self - .state - .remove(&name) - .ok_or_else(|| Error::UndefinedVariable(name))?); - } - - pub fn get(&self, name: String) -> Result { - let x: &rhai::Dynamic = self - .state - .get(&name) - .ok_or_else(|| Error::UndefinedVariable(name))?; - let x: Value = match x.clone().try_cast_result() { - Err(e) => Err(Error::Rhai(format!("{}", e)))?, - Ok(x) => x, - }; - let x: toml::Value = x.into(); - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - return match x.serialize(&to_json) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, - Ok(x) => Ok(x), - }; - } - - pub fn add_to_command_queue(&mut self, queue: String, x: Command) { - let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); - queue.push_back(x); - // TODO: pop queue if it gets too large - } - - pub fn pop_command_queue(&mut self, queue: String) -> Option { - let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); - return queue.pop_front(); - } - - // TODO: function to evaluate args of replay and return a range of expressions - // to replay in type script -} - -#[wasm_bindgen] -impl Command { - pub(crate) fn toml_args(&self, scope: &mut Scope) -> ResultVec { - let flat_args = scope.expand(&self.args)?; - return Ok(toml::Value::from(flat_args)); - } - - pub fn args(&self, scope: &mut Scope) -> ResultVec { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - return match self.toml_args(scope)?.serialize(&to_json) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, - Ok(x) => Ok(x), - }; - } -} - -impl Command { - pub fn new(input: CommandInput) -> ResultVec { - if let Some(_) = input.id { - return reserved("id")?; - } - return Ok(Command { - command: input.command.resolve("`command` field")?, - args: match input.args { - Some(x) => x.into_inner(), - None => Value::Table(IndexMap::new()), - }, - }); - } -} - -#[derive(Clone, Debug, Serialize)] -#[allow(non_snake_case)] -#[wasm_bindgen(getter_with_clone)] -pub struct Binding { - pub key: String, - pub commands: Vec, - pub when: Option, - pub mode: Vec, - pub priority: f64, - pub prefixes: Vec, - pub finalKey: bool, - pub(crate) repeat: Option>, - pub name: Option, - pub description: Option, - pub hideInPalette: bool, - pub hideInDocs: bool, - pub combinedName: Option, - pub combinedKey: Option, - pub combinedDescription: Option, - pub kind: Option, -} - -#[wasm_bindgen] -impl Binding { - pub fn repeat_count(&self) -> std::result::Result { - return Ok("TODO".into()); - } -} - -// TODO: define functions for variable expansion on `Binding??` - -// TODO: convert errors to my own error type for Validation and serde_wasm_bindgen error - -impl BindingInput { - fn has_foreach(&self) -> bool { - if let Some(foreach) = &self.foreach { - return foreach.len() > 0; - } - return false; - } - - pub fn expand_foreach(self) -> ResultVec> { - if self.has_foreach() { - let foreach = expand_keys(self.foreach.clone().unwrap())?; - foreach.require_constant().context_str( - "`foreach` values can only include expressions of the form {{keys(`regex`)}}", - )?; - - let values = expand_foreach_values(foreach).into_iter().map(|values| { - let mut result = self.clone(); - result.foreach = None; - result - .map_expressions(&mut |x| { - Ok(values - .get(&x) - .map_or_else(|| Value::Expression(x), |ex| ex.clone())) - }) - .expect("no errors") // since our mapping function has no errors - }); - return Ok(values.collect()); - } - return Ok(vec![self]); - } -} - -fn expand_foreach_values(foreach: IndexMap>) -> Vec> { - let mut result = vec![IndexMap::new()]; - - for (k, vals) in foreach { - result = result - .iter() - .flat_map(|seed| { - vals.iter().map(|v| { - let mut with_k = seed.clone(); - with_k.insert(k.clone(), v.clone()); - return with_k; - }) - }) - .collect(); - } - - return result; -} - impl Expanding for BindingInput { fn is_constant(&self) -> bool { [ @@ -617,14 +257,7 @@ impl Expanding for BindingInput { self.prefixes.is_constant(), self.finalKey.is_constant(), self.repeat.is_constant(), - self.name.is_constant(), - self.description.is_constant(), - self.hideInPalette.is_constant(), - self.hideInDocs.is_constant(), - self.combinedName.is_constant(), - self.combinedKey.is_constant(), - self.combinedDescription.is_constant(), - self.kind.is_constant(), + self.doc.is_constant(), ] .into_iter() .all(identity) @@ -680,6 +313,123 @@ impl Expanding for BindingInput { errors.append(&mut e.errors); None }), + doc: self.doc.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + }; + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } + } +} + +// +// ---------------- `bind.doc` parsing ---------------- +// + +#[derive(Deserialize, Serialize, Clone, Debug)] +pub struct BindingDocInput { + /// @forBindingField bind + /// @order 10 + /// + /// ## Documentation + /// + /// The documentation object `bind.doc` is composed of the following fields + /// + /// - `name`: A very brief description for the command; this must fit in the visual + /// documentation of keybindings so it shouldn't be much longer than five characters for most + /// keys. Favor unicode symbols such as →/← over text like left/right. + #[serde(default)] + pub name: Option>>, + + /// @forBindingField bind + /// @order 10 + /// + /// - `description`: A sentence or two about the command. Save more detailed descriptions + /// for the comments around your keybindings: the keybinding file is a literate + /// document and all users can see these comments when reviewing the textual documentation. + #[serde(default)] + pub description: Option>>, + /// @forBindingField bind + /// @order 10 + /// + /// - `hideInPalette/hideInDocs`: whether to show the keys in the popup suggestions + /// and the documentation. These both default to false. + #[serde(default)] + pub hideInPalette: Option>>, + #[serde(default)] + pub hideInDocs: Option>>, + + /// @forBindingField bind + /// @order 10 + /// + /// - `combinedName/combinedKey/combinedDescription`: in the suggestion palette and + /// textual documentation, keys that have the same `combinedName` will be + /// represented as single entry, using the `combinedKey` and `combinedDescription` + /// instead of `key` and `description`. The `combinedKey` for a multi-key sequence + /// should only include the suffix key. You need only define `combinedKey` and + /// `combinedDescription` once across keys that share the same `combinedName` + /// entry. + #[serde(default)] + pub combinedName: Option>>, + #[serde(default)] + pub combinedKey: Option>>, + #[serde(default)] + pub combinedDescription: Option>>, + + /// @forBindingField bind + /// @order 10 + /// + /// - `kind`: The broad cagegory of commands this binding falls under. There should + /// be no more than 4-5 of these. Each `kind` here should have a corresponding + /// entry in the top-level `kind` array. + #[serde(default)] + pub kind: Option>>, +} + +impl Merging for BindingDocInput { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, y: Self) -> Self { + BindingDocInput { + name: self.name.coalesce(y.name), + description: self.description.coalesce(y.description), + hideInPalette: self.hideInPalette.coalesce(y.hideInPalette), + hideInDocs: self.hideInDocs.coalesce(y.hideInDocs), + combinedName: self.combinedName.coalesce(y.combinedName), + combinedKey: self.combinedKey.coalesce(y.combinedKey), + combinedDescription: self.combinedDescription.coalesce(y.combinedDescription), + kind: self.kind.coalesce(y.kind), + } + } +} + +impl Expanding for BindingDocInput { + fn is_constant(&self) -> bool { + [ + self.name.is_constant(), + self.description.is_constant(), + self.hideInPalette.is_constant(), + self.hideInDocs.is_constant(), + self.combinedName.is_constant(), + self.combinedKey.is_constant(), + self.combinedDescription.is_constant(), + self.kind.is_constant(), + ] + .into_iter() + .all(identity) + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + Self: Sized, + F: FnMut(String) -> Result, + { + let mut errors = Vec::new(); + let result = BindingDocInput { name: self.name.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); None @@ -729,87 +479,23 @@ impl Expanding for BindingInput { } } -fn regularize_commands(input: &BindingInput) -> ResultVec> { - let command: String = input.clone().command.resolve("`command` field")?; - if command != "runCommands" { - let commands = vec![Command { - command, - args: match &input.args { - None => Value::Table(IndexMap::new()), - Some(spanned) => spanned.as_ref().clone(), - }, - }]; - return Ok(commands); - } else { - let spanned = input - .args - .as_ref() - .ok_or_else(|| Error::Constraint("`runCommands` must have `args` field".to_string()))?; - let args_pos = spanned.span(); - let args = spanned.as_ref().to_owned(); - let commands = match args { - Value::Table(kv) => kv - .get("commands") - .ok_or_else(|| { - Error::Constraint("`runCommands` must have `args.commands` field".into()) - })? - .clone(), - _ => Err(Error::Validation( - "Expected `args` to be an object with `commands` field".to_string(), - ))?, - }; - let command_vec = match commands { - Value::Array(items) => items, - _ => Err(Error::Validation( - "Expected `args.commands` of `runCommands` to \ - be a vector of commands to run." - .to_string(), - ))?, - }; - - let mut command_result = Vec::with_capacity(command_vec.len()); - - for command in command_vec { - let (command, args) = match command { - Value::String(str) => (str.to_owned(), Value::Table(IndexMap::new())), - Value::Table(kv) => { - let result = kv.get("command").ok_or_else({ - || { - Error::RequiredField( - "`args.commands.command` field for `runCommands`".into(), - ) - } - })?; - let command_name = match result { - Value::String(x) => x.to_owned(), - _ => { - return Err(Error::Constraint("`command` to be a string".into())) - .context_range(&args_pos)?; - } - }; - let result = kv.get("args").ok_or_else(|| { - Error::RequiredField("`args.commands.arg` field for `runCommands`".into()) - })?; - let args = match result { - x @ Value::Table(_) => x, - x @ Value::Array(_) => x, - _ => { - return Err(Error::Constraint("`args` to be a table or array".into()))?; - } - }; - (command_name, args.to_owned()) - } - _ => { - return constrain( - "`commands` to be an array that includes objects and strings only", - )?; - } - }; - command_result.push(Command { command, args }) - } +// +// ================ `[[bind]]` object ================ +// - return Ok(command_result); - } +#[derive(Clone, Debug, Serialize)] +#[allow(non_snake_case)] +#[wasm_bindgen(getter_with_clone)] +pub struct Binding { + pub key: String, + pub commands: Vec, + pub when: Option, + pub mode: Vec, + pub priority: f64, + pub prefixes: Vec, + pub finalKey: bool, + pub(crate) repeat: Option>, + pub doc: Option, } #[wasm_bindgen] @@ -842,6 +528,36 @@ impl Binding { prefixes: input.prefixes.resolve("`prefixes` fields")?, finalKey: input.finalKey.resolve("`finalKey` field")?.unwrap_or(true), repeat: input.repeat.resolve("`repeat` field")?, + doc: match input.doc { + Some(doc) => Some(BindingDoc::new(doc)?), + None => None, + }, + }); + } +} + +// +// ---------------- `bind.doc` object ---------------- +// + +#[derive(Clone, Debug, Serialize)] +#[allow(non_snake_case)] +#[wasm_bindgen(getter_with_clone)] +pub struct BindingDoc { + pub name: Option, + pub description: Option, + pub hideInPalette: bool, + pub hideInDocs: bool, + pub combinedName: Option, + pub combinedKey: Option, + pub combinedDescription: Option, + pub kind: Option, +} + +#[wasm_bindgen] +impl BindingDoc { + pub(crate) fn new(input: BindingDocInput) -> ResultVec { + return Ok(BindingDoc { name: input.name.resolve("`name` field")?, description: input.description.resolve("`description` field")?, hideInPalette: input @@ -862,10 +578,17 @@ impl Binding { } } +// +// ================ Tests ================ +// + #[cfg(test)] mod tests { use test_log::test; + use rhai::Dynamic; + use std::collections::HashMap; + use super::*; #[test] fn complete_parsing() { @@ -901,7 +624,7 @@ mod tests { let args = result.args.unwrap().into_inner(); assert_eq!( args, - Value::Table(IndexMap::from([ + Value::Table(BTreeMap::from([ ("a".into(), Value::String("2".into())), ("b".into(), Value::Integer(3)) ])) @@ -986,7 +709,7 @@ mod tests { ); assert_eq!( result.args.unwrap().into_inner(), - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "to".into(), Value::String("left".into()) )])) @@ -1029,7 +752,7 @@ mod tests { assert_eq!( left.args.unwrap().into_inner(), - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "to".into(), Value::String("left".into()) )])) @@ -1155,7 +878,7 @@ mod tests { ); assert_eq!( item.args.unwrap().into_inner(), - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "value".to_string(), Value::String(expected_value[i].into()) )])) @@ -1188,7 +911,7 @@ mod tests { let value = items[i].args.as_ref().unwrap().get_ref().clone(); assert_eq!( value, - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "value".to_string(), Value::String(expected_value[i].clone()) )])) diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs new file mode 100644 index 00000000..7406eb94 --- /dev/null +++ b/src/rust/parsing/src/bind/command.rs @@ -0,0 +1,224 @@ +use std::collections::BTreeMap; +use serde::{Deserialize, Serialize}; +use toml::Spanned; +use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; + +use crate::{ + bind::{BindingInput, UNKNOWN_RANGE}, + error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, constrain, reserved}, + expression::Scope, + expression::value::{Expanding, TypedValue, Value}, + util::{Required, Resolving}, +}; + +/// @forBindingField bind @order 15 +/// +/// ## Running Multiple Commands +/// +/// When `bind.command` is set to `runCommands`, you can run multiple commands with a single +/// key press. The`bind.args.commands` list is an array that can contain the following +/// types: +/// +/// - string: the name of the command to run +/// - object: with `command`, and optionally `args` and `skipWhen` fields. +/// - an expression referencing a command `{{command.[commandId]}}`; this is a +/// command defined in the [`[[define]]`](/bindings/define) section. +/// +/// The object fields are defined as follows: +/// +#[derive(Deserialize, Clone, Debug)] +pub struct CommandInput { + // should only be `Some` in context of `Define(Input)` + pub(crate) id: Option>>, + /// @forBindingField bind @order 15 + /// - ❗`command`: as per the top level `command` field, this is a the command you wish to + /// run. + pub command: Spanned>>, + /// @forBindingField bind @order 15 + /// - ⚡ `args`: as per the top level `args` field. Can include + /// runtime [expressions](/expressions/index). + /// - ⚡ `skipWhen`: an [expression](/expressions/index) that, when evaluated to false, will + /// cause the command to *not* be run. + // **TODO**: implement `skipWhen` + pub args: Option>, +} + +impl Expanding for CommandInput { + fn is_constant(&self) -> bool { + if self.command.is_constant() { + return false; + } + if self.args.is_constant() { + return false; + } + return true; + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + let mut errors = Vec::new(); + let result = CommandInput { + id: self.id, + command: self.command.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) + }), + args: self.args.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + }; + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } + } +} + +impl CommandInput { + pub(crate) fn without_id(&self) -> Self { + return CommandInput { + id: None, + command: self.command.clone(), + args: self.args.clone(), + }; + } +} + +impl From for Value { + fn from(value: CommandInput) -> Self { + let mut entries = BTreeMap::new(); + let command = value.command.into_inner(); + if let Required::Value(command_value) = command { + entries.insert("command".to_string(), command_value.into()); + } + if let Some(arg_value) = value.args { + entries.insert("args".to_string(), arg_value.into_inner()); + } + return Value::Table(entries); + } +} + +pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec> { + let command: String = input.clone().command.resolve("`command` field")?; + if command != "runCommands" { + let commands = vec![Command { + command, + args: match &input.args { + None => Value::Table(BTreeMap::new()), + Some(spanned) => spanned.as_ref().clone(), + }, + }]; + return Ok(commands); + } else { + let spanned = input + .args + .as_ref() + .ok_or_else(|| Error::Constraint("`runCommands` must have `args` field".to_string()))?; + let args_pos = spanned.span(); + let args = spanned.as_ref().to_owned(); + let commands = match args { + Value::Table(kv) => kv + .get("commands") + .ok_or_else(|| { + Error::Constraint("`runCommands` must have `args.commands` field".into()) + })? + .clone(), + _ => Err(Error::Validation( + "Expected `args` to be an object with `commands` field".to_string(), + ))?, + }; + let command_vec = match commands { + Value::Array(items) => items, + _ => Err(Error::Validation( + "Expected `args.commands` of `runCommands` to \ + be a vector of commands to run." + .to_string(), + ))?, + }; + + let mut command_result = Vec::with_capacity(command_vec.len()); + + for command in command_vec { + let (command, args) = match command { + Value::String(str) => (str.to_owned(), Value::Table(BTreeMap::new())), + Value::Table(kv) => { + let result = kv.get("command").ok_or_else({ + || { + Error::RequiredField( + "`args.commands.command` field for `runCommands`".into(), + ) + } + })?; + let command_name = match result { + Value::String(x) => x.to_owned(), + _ => { + let err: ErrorWithContext = + Error::Constraint("`command` to be a string".into()).into(); + Err(err).context_range(&args_pos)? + } + }; + let result = kv.get("args").ok_or_else(|| { + Error::RequiredField("`args.commands.arg` field for `runCommands`".into()) + })?; + let args = match result { + x @ Value::Table(_) => x, + x @ Value::Array(_) => x, + _ => { + return Err(Error::Constraint("`args` to be a table or array".into()))?; + } + }; + (command_name, args.to_owned()) + } + _ => { + return constrain( + "`commands` to be an array that includes objects and strings only", + )?; + } + }; + command_result.push(Command { command, args }) + } + + return Ok(command_result); + } +} + +#[wasm_bindgen(getter_with_clone)] +#[derive(Clone, Debug, Serialize)] +pub struct Command { + pub command: String, + pub(crate) args: Value, +} + +#[wasm_bindgen] +impl Command { + pub(crate) fn toml_args(&self, scope: &mut Scope) -> ResultVec { + let flat_args = scope.expand(&self.args)?; + return Ok(toml::Value::from(flat_args)); + } + + pub fn args(&self, scope: &mut Scope) -> ResultVec { + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + return match self.toml_args(scope)?.serialize(&to_json) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => Ok(x), + }; + } +} + +impl Command { + pub fn new(input: CommandInput) -> ResultVec { + if let Some(_) = input.id { + return reserved("id")?; + } + return Ok(Command { + command: input.command.resolve("`command` field")?, + args: match input.args { + Some(x) => x.into_inner(), + None => Value::Table(BTreeMap::new()), + }, + }); + } +} diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index b6fdced2..c4a5988b 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -1,14 +1,52 @@ -use std::collections::VecDeque; +/// @forBindingField bind +/// @order 20 +/// +/// ## `foreach` Clauses +/// +/// The `bind.foreach` field of a keybinding can be used to generate many bindings from one +/// entry. Each field under `foreach` is looped through exhaustively. On each iteration, any +/// expressions with `foreach` defined variables are replaced with those variables' values +/// for the given iteration. For example, the following defines 9 bindings: +/// +/// ::: v-pre +/// ```toml +/// [[bind]] +/// foreach.a = [1,2,3] +/// foreach.b = [1,2,3] +/// key = "ctrl+; {{a}} {{b}}" +/// command = "type" +/// args.text = "{{a-b}}" +/// ``` +/// ::: +/// +/// Furthermore, if the expression {{keys(`[regex]`)}} is included in a +/// `foreach` value, it is expanded to all keybindings that match the given regular +/// expression and spliced into the array of values. For example, the following definition +/// is used in `Larkin` to allow the numeric keys to be used as count prefix for motions. +/// +/// ::: v-pre +/// ```toml +/// [[bind]] +/// foreach.num = ['{{key(`[0-9]`)}}'] # matches all numeric keybindings +/// name = "count {{num}}" +/// key = "{{num}}" +/// command = "master-key.updateCount" +/// description = "Add digit {{num}} to the count argument of a command" +/// args.value = "{{num}}" +/// # etc... +/// ``` +/// ::: +use crate::bind::BindingInput; -use indexmap::IndexMap; use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; +use std::collections::BTreeMap; use toml::Spanned; use crate::error::{ErrorContext, Result, ResultVec}; -use crate::value::{Expanding, Value}; +use crate::expression::value::{Expanding, Value}; const ALL_KEYS: [&'static str; 192] = [ "f0", @@ -227,8 +265,8 @@ fn expand_keys_str(val: String) -> Result { } pub fn expand_keys( - items: IndexMap>>, -) -> ResultVec>> { + items: BTreeMap>>, +) -> ResultVec>> { // expand any `{{key(`regex`)}}` expressions (these are arrays of possible keys) let items = items.map_expressions(&mut expand_keys_str)?; @@ -247,3 +285,54 @@ pub fn expand_keys( }) .collect()); } + +impl BindingInput { + fn has_foreach(&self) -> bool { + if let Some(foreach) = &self.foreach { + return foreach.len() > 0; + } + return false; + } + + pub fn expand_foreach(self) -> ResultVec> { + if self.has_foreach() { + let foreach = expand_keys(self.foreach.clone().unwrap())?; + foreach.require_constant().context_str( + "`foreach` values can only include expressions of the form {{keys(`regex`)}}", + )?; + + let values = expand_foreach_values(foreach).into_iter().map(|values| { + let mut result = self.clone(); + result.foreach = None; + result + .map_expressions(&mut |x| { + Ok(values + .get(&x) + .map_or_else(|| Value::Expression(x), |ex| ex.clone())) + }) + .expect("no errors") // since our mapping function has no errors + }); + return Ok(values.collect()); + } + return Ok(vec![self]); + } +} + +fn expand_foreach_values(foreach: BTreeMap>) -> Vec> { + let mut result = vec![BTreeMap::new()]; + + for (k, vals) in foreach { + result = result + .iter() + .flat_map(|seed| { + vals.iter().map(|v| { + let mut with_k = seed.clone(); + with_k.insert(k.clone(), v.clone()); + return with_k; + }) + }) + .collect(); + } + + return result; +} diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index afdf6123..9c5d9f4e 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,6 +1,6 @@ -use crate::error::{Error, ErrorWithContext, ErrorsWithContext, Result, ResultVec}; +use crate::error::{Error, ErrorsWithContext, Result, ResultVec}; +use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; use crate::util::{Merging, Resolving}; -use crate::value::{EXPRESSION, Expanding, TypedValue, Value}; #[allow(unused_imports)] use log::info; @@ -9,6 +9,10 @@ use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; +// +// ---------------- Keybinding Validation ---------------- +// + lazy_static! { static ref MODIFIER_REGEX: Regex = Regex::new(r"(?i)Ctrl|Shift|Alt|Cmd|Win|Meta").unwrap(); static ref KEY_REGEXS: Vec = vec![ @@ -191,11 +195,18 @@ impl KeyBinding { } } +// +// ---------------- References to `bind` object ---------------- +// + lazy_static! { static ref BIND_VARIABLE: Regex = Regex::new(r"bind\.([\w--\d][\w]*)").unwrap(); } -#[derive(Deserialize, Clone, Debug)] +/// A `BindingReference` is an expression of the form `{{bind.[bindID]}}`, and it +/// resolved to a `[[define.bind]]` defined partial keybinding object. + +#[derive(Deserialize, Clone, Debug, Serialize)] #[serde(try_from = "String", into = "String")] pub struct BindingReference(pub(crate) String); @@ -223,14 +234,14 @@ impl TryFrom for BindingReference { } // This implementation of `Expanding` may seem unintuitive, but we don't actually use -// `map-expressions` to expand `BindingReference` instead we review review these values -// during a separate `BindingInput` resolution phase. During variable expansion, we simply -// want to ignore the `{{bind.}}` expression present in `BindingReference` +// `map-expressions` to expand `BindingReference`. Instead we review these values during a +// separate `BindingInput` resolution phase (see file.rs). During variable expansion, we +// simply want to ignore the `{{bind.}}` expression present in `BindingReference` impl Expanding for BindingReference { fn is_constant(&self) -> bool { false } - fn map_expressions(self, f: &mut F) -> ResultVec + fn map_expressions(self, _f: &mut F) -> ResultVec where Self: Sized, F: FnMut(String) -> Result, diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 056687e7..593c8b10 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,42 +1,184 @@ -// TODO: refactor this *AFTER* we've got `bind` working again - -use core::error; -use std::collections::{HashMap, hash_map}; - -use crate::bind::validation::BindingReference; -use crate::bind::{Binding, BindingInput, Command, CommandInput}; -use crate::error::{Context, Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; -use crate::util::{Merging, Resolving}; -use crate::value::{Expanding, Value}; - -use indexmap::IndexMap; -use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; + +use lazy_static::lazy_static; use regex::Regex; +use rhai::Dynamic; use serde::{Deserialize, Serialize}; -use serde_wasm_bindgen; +use std::collections::BTreeMap; +use std::collections::{HashMap, hash_map}; use toml::Spanned; -use wasm_bindgen::prelude::*; +use crate::bind::BindingInput; +use crate::bind::command::CommandInput; +use crate::bind::validation::BindingReference; +use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; +use crate::expression::Scope; +use crate::expression::value::{Expanding, Value}; +use crate::util::{Merging, Resolving}; + +/// @bindingField define +/// @description object of arbitrary fields which can be used in +/// computed arguments. +/// +/// The `define` field can be used to define re-usable values. There are three types of +/// values that be defined. +/// +/// 1. `[[define.var]]:` variable definitions: defines any number of key-value pairs that can +/// be referenced inside an [expression](/expressions/index) +/// 2. `[[define.command]]`: command definitions: defines one or more commands that can be +/// referenced when [running multiple commands](/bindings/bind#running-multiple-commands). +/// 3. `[[define.bind]]`: bind definitions: defines a partial set of `command` fields that can +/// be referenced using the `default` field of [bind](/bindings/bind). +/// #[derive(Deserialize, Clone, Debug, Default)] pub struct DefineInput { - pub var: Option>>>, + /// @bindingField define + /// + /// ## Variable Definitions + /// + /// These can be any arbitrary TOML values. You can define multiple variables within + /// each `[[define.var]]` element this way. These are then available in any expressions + /// evaluated at runtime. + /// + /// ### Example + /// + /// A common command pattern in Larkin is to allow multiple lines to be selected using a + /// count followed by the operation to perform on those lines. The line selection is + /// defined as follows + /// + /// To handle symmetric insert of brackets, Larkin uses the following definition + /// + /// ```toml + /// [define.braces] + /// "{".before = "{" + /// "{".after = "}" + /// "}".before = "{" + /// "}".after = "}" + /// "[".before = "[" + /// "[".after = "]" + /// "]".before = "[" + /// "]".after = "]" + /// "(".before = "(" + /// "(".after = ")" + /// ")".before = "(" + /// ")".after = ")" + /// "<".before = "<" + /// "<".after = ">" + /// ">".before = "<" + /// ">".after = ">" + /// ``` + /// + /// This is then applied when handling symmetric typing using the + /// [`onType`](/bindings/mode#ontype-field) field of `[[mode]]`. + /// + /// ```toml + /// [[mode]] + /// name = "syminsert" + /// highlight = "Highlight" + /// cursorShape = "BlockOutline" + /// + /// [[mode.onType]] + /// command = "selection-utilities.insertAround" + /// args.before = "{{braces[captured].?before ?? captured}}" + /// args.after = "{{braces[captured].?after ?? captured}}" + /// args.followCursor = true + /// ``` + pub var: Option>>>, + /// @bindingField define + /// + /// ## Command Definitions + /// + /// You can define re-usable commands that can be run when running + /// [running multiple commands](/bindings/bind#running-multiple-commands). + /// + /// In addition the normal fields of a command, you must provide an `id` to refer to the + /// command as `{{command.[id]}}`. + /// + /// ### Example + /// + /// Larkin defines commands to select N lines downwards + /// + /// ```toml + /// [[define.command]] + /// id = "selectLinesDown" + /// command = "runCommands" + /// args.commands = [ + /// "selection-utilities.shrinkToActive", + /// { skipWhen = "{{count <= 0}}", command = "cursorMove", args = { to = "down", by = "wrappedLine", select = true, value = "{{count}}" } }, + /// "expandLineSelection", + /// "selection-utilities.exchangeAnchorActive", + /// ] + /// ``` + /// And uses this definition is as follows + /// + /// ```toml + /// [[bind]] + /// default = "{{bind.edit_action}}" + /// key = "c" + /// when = "!editorHasSelection && master-key.count > 1" + /// command = "runCommands" + /// args.commands = [ + /// "{{command.selectLinesDown}}", + /// "deleteRight", + /// "editor.action.insertLineBefore", + /// "master-key.enterInsert", + /// ] + /// ``` pub command: Option>>, + /// @bindingField define + /// + /// ## Binding Definitions + /// + /// You can define partial [bind](/bindings/bind) definitions, e.g. for common default + /// values to use across many bindings. + /// + /// The `args` field is merged recursively, allowing you to specify some arguments in + /// the default `[[define.bind]]` and others in `[[bind]]` directly. + /// + /// ### Example + /// + /// Larkin makes extensive use of this for the simple cursor motions. The default + /// command is always `cursorMove` and each motion indications in what direction to move + /// using `args.value.` + /// + /// ```toml + /// [[define.bind]] + /// id = "edit_motion_prim" + /// default = "{{bind.edit_motion}}" + /// command = "cursorMove" + /// args.value = "{{count}}" + /// args.select = "{{editorHasSelection}}" + /// + /// [[bind]] + /// default = "{{bind.edit_motion_prim}}" + /// key = "h" + /// args.to = "left" + /// mode = "normal" + /// + /// [[bind]] + /// default = "{{bind.edit_motion_prim}}" + /// key = "l" + /// args.to = "right" + /// ``` + /// pub bind: Option>>, } -#[wasm_bindgen] -#[derive(Clone, Debug, Default)] +#[derive(Clone, Debug, Default, Serialize)] pub struct Define { - #[wasm_bindgen(skip)] + #[serde(skip)] pub bind: HashMap, - #[wasm_bindgen(skip)] + #[serde(skip)] pub command: HashMap, - #[wasm_bindgen(skip)] pub var: HashMap, } +lazy_static! { + pub static ref BIND_REF: Regex = Regex::new(r"^bind\.([\w--\d]+\w*)$").unwrap(); + pub static ref COMMAND_REF: Regex = Regex::new(r"^command\.([\w--\d]+\w*)$").unwrap(); +} + impl Define { pub fn new(input: DefineInput) -> ResultVec { let mut resolved_bind = HashMap::::new(); @@ -107,34 +249,17 @@ impl Define { }); } } -} -// NOTE: why don't we provide public access to `bind` and `command`: this avoids -// extra implementation work, when the main use case for these two categories of -// definitions is to make the binding file more concise; `var.` values on -// the other hand are often used at runtime -#[wasm_bindgen] -impl Define { - // TODO: implement rhai evaluation - pub fn var(&self, key: &str) -> Result { - let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - let value = self - .var - .get(key) - .ok_or_else(|| Error::RequiredField(format!("`{key}` field")))?; - return match value.serialize(&to_json) { - Ok(result) => Ok(result), - Err(_) => unexpected("unexpected serialization error"), - }; + pub fn add_to_scope(&self, scope: &mut Scope) -> ResultVec<()> { + for (k, v) in self.var.iter() { + v.require_constant()?; + let val: Dynamic = v.clone().into(); + // TODO: add all of these to a `var.` value + scope.state.set_or_push(k, val); + } + return Ok(()); } -} -lazy_static! { - pub static ref BIND_REF: Regex = Regex::new(r"^bind\.([\w--\d]+\w*)$").unwrap(); - pub static ref COMMAND_REF: Regex = Regex::new(r"^command\.([\w--\d]+\w*)$").unwrap(); -} - -impl Define { pub fn expand(&mut self, binding: BindingInput) -> ResultVec { // resolve default values let binding = if let Some(ref default) = binding.default { @@ -152,7 +277,7 @@ impl Define { } else { default_value = occupied_entry.get().clone() } - default_value.merge(binding) + default_value.without_id().merge(binding) } else { binding }; @@ -213,7 +338,7 @@ mod tests { let args = foo.args.as_ref().unwrap().clone().into_inner(); assert_eq!( args, - Value::Table(IndexMap::from([ + Value::Table(BTreeMap::from([ ("k".into(), Value::Integer(1)), ("h".into(), Value::Integer(2)) ])) @@ -225,7 +350,7 @@ mod tests { let commands = foobar.args.as_ref().unwrap().clone().into_inner(); assert_eq!( commands, - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "commands".into(), Value::Array(vec![ Value::String("foo".into()), diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs new file mode 100644 index 00000000..e7318c82 --- /dev/null +++ b/src/rust/parsing/src/expression.rs @@ -0,0 +1,178 @@ +// TODO: here is where we would want to invoke rhai to resolve any outstanding expressions + +pub mod value; + +use std::collections::{HashMap, VecDeque}; + +use rhai::Dynamic; +use serde::Serialize; +use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; + +use crate::{ + bind::command::Command, error::Error, error::Result, error::ResultVec, + expression::value::Expanding, expression::value::Value, +}; + +/// @file expressions/index.md +/// +/// # Expressions +/// +/// You can use expressions in a number of places inside a [bind](/bindings/bind) +/// definition. An expression is a snippet of code surrounded by double curly braces {{like + this}} that occurs within a TOML string. When the string begins +/// and ends with the curly braces of the expression that string can evaluate to any valid +/// TOML object. If there is additional text outside of the string, the expression will be +/// converted to a string and interpolated into the the surrounding text. +/// +/// Valid expressions are a simple subset of [Rhai](https://rhai.rs/book/ref/index.html). +/// You cannot execute statements, set variables, use loops, or define. If you find yourself +/// wanting to write an elaborate expression, your goal is probably better accomplished by +/// writing an [extension](https://code.visualstudio.com/api) and running the extension +/// defined command. +/// +/// There are two points at which an expression can be evaluated: while parsing the master +/// keybinding file (e.g. making use of [foreach](/bindings/bind#foreach-clauses)) or at +/// runtime: when the user presses a key. +/// +/// ## Parse-time Evaluation +/// +/// Parse-time expressions improve expressivity of the keybinding spec. They are generally +/// quite limited in terms of what values are in scope within the expression. The individual +/// fields of `bind` document the scope of a given parse-time expression. +/// +/// ## Run-time Evaluation +/// +/// Expressions that get evaluated at run time are clearly denoted as such with a ⚡ emoji. +/// They are more expressive, and have access to the following values: +/// +/// - Any field defined in a [`[[define.var]]`](/bindings/define) section. These variables +/// are all stored under the top-level `var.` object. +/// - `code.editorHasSelection`: true if there is any selection, false otherwise +/// - `code.editorHasMultipleSelections`: true if there are multiple selections, false +/// otherwise +/// - `code.firstSelectionOrWord`: the first selection, or the word under the first cursor +/// if the selection is empty +/// - `code.editorLangId`: the [language +/// id](https://code.visualstudio.com/docs/languages/identifiers) of the current editor or +/// the empty string if there is no current editor (or no language id for that editor) +/// - `key.mode`: the current keybinding mode +/// - `key.count`: The current count, as defined by +/// [`master-key.updateCount`](/commands/updateCount) +/// - `key.captured`: The text currently captured by the most recent call to +/// [`master-key.restoreNamed`](/commands/restoreNamed) or +/// [`master-key.captureKeys`](/commands/captureKeys). +/// - `key.prefix`: The currently active [keybinding prefix](/commands/prefix) +/// - `key.record`: a boolean flag used to indicate when keys are marked for recording +/// - `key.commandsHistory`: an array containing all previously run master key commands, up +/// to the number configured by Master Key's "Command History Maximum" (defaults to 1024). +/// Commands are stored from least recent (smallest index) to most recent (largest index). + +#[wasm_bindgen] +pub struct Scope { + pub(crate) asts: HashMap, + engine: rhai::Engine, + pub(crate) state: rhai::Scope<'static>, + pub(crate) queues: HashMap>, +} + +// TODO: we'll need to define `CustomType` on `Value` and `Command` +#[wasm_bindgen] +impl Scope { + // TODO: incorporate command queues + pub(crate) fn expand(&mut self, obj: &T) -> ResultVec + where + T: Expanding + Clone, + { + for (k, v) in self.queues.iter() { + // TODO: tell engine how to handle dequeues + // TODO: I don't love that we have to copy the queue for every evaluation + // this will have to be fixed to avoid ridiculous amounts of copying + // per command run + + // PLAN: make queue type a CustomType and track it in `state` instead of + // in `queues`. + self.state.set_or_push(k, v.clone()); + } + return Ok(obj.clone().map_expressions(&mut |expr| { + let ast = &self.asts[&expr]; + let result = self.engine.eval_ast_with_scope(&mut self.state, &ast); + let value: rhai::Dynamic = match result { + Err(x) => Err(Error::ExpressionEval(format!("{}", x)))?, + Ok(x) => x, + }; + let result_value: Value = value.clone().try_into()?; + return Ok(result_value); + })?); + } + + pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { + x.clone().map_expressions(&mut |expr| { + let ast = self.engine.compile_expression(expr.clone())?; + self.asts.insert(expr.clone(), ast); + return Ok(Value::Expression(expr)); + })?; + return Ok(()); + } + + #[wasm_bindgen(constructor)] + pub fn new() -> Scope { + let mut engine = rhai::Engine::new(); + engine.set_allow_looping(false).allow_statement_expression(); + + return Scope { + asts: HashMap::new(), + engine: engine, + state: rhai::Scope::new(), + queues: HashMap::new(), + }; + } + + pub fn set(&mut self, name: String, value: JsValue) -> Result<()> { + let toml: toml::Value = match serde_wasm_bindgen::from_value(value) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => x, + }; + let val: Value = toml.try_into()?; + let val: Dynamic = val.into(); + self.state.set_or_push(&name, val); + return Ok(()); + } + + pub fn unset(&mut self, name: String) -> Result<()> { + return Ok(self + .state + .remove(&name) + .ok_or_else(|| Error::UndefinedVariable(name))?); + } + + pub fn get(&self, name: String) -> Result { + let x: &rhai::Dynamic = self + .state + .get(&name) + .ok_or_else(|| Error::UndefinedVariable(name))?; + let x: Value = match x.clone().try_cast_result() { + Err(e) => Err(Error::Rhai(format!("{}", e)))?, + Ok(x) => x, + }; + let x: toml::Value = x.into(); + let to_json = serde_wasm_bindgen::Serializer::json_compatible(); + return match x.serialize(&to_json) { + Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Ok(x) => Ok(x), + }; + } + + pub fn add_to_command_queue(&mut self, queue: String, x: Command) { + let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); + queue.push_back(x); + // TODO: pop queue if it gets too large + } + + pub fn pop_command_queue(&mut self, queue: String) -> Option { + let queue = self.queues.entry(queue).or_insert_with(|| VecDeque::new()); + return queue.pop_front(); + } + + // TODO: function to evaluate args of replay and return a range of expressions + // to replay in type script +} diff --git a/src/rust/parsing/src/value.rs b/src/rust/parsing/src/expression/value.rs similarity index 90% rename from src/rust/parsing/src/value.rs rename to src/rust/parsing/src/expression/value.rs index 6fb79b3e..22fe3d5d 100644 --- a/src/rust/parsing/src/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -1,30 +1,28 @@ -use std::any::TypeId; -use std::collections::VecDeque; -use std::error; -use std::io; -use std::io::Write; - -use js_sys::Boolean; #[allow(unused_imports)] use log::info; -use indexmap::IndexMap; +use std::collections::BTreeMap; use lazy_static::lazy_static; use regex::Regex; use rhai::Dynamic; -use rhai::{AST, CustomType, Engine}; use serde::{Deserialize, Serialize}; +use std::io; +use std::io::Write; use toml::Spanned; -use toml::ser::Buffer; -use crate::error::{ - Error, ErrorContext, ErrorWithContext, ErrorsWithContext, Result, ResultVec, flatten_errors, -}; +use crate::error::{Error, ErrorContext, ErrorsWithContext, Result, ResultVec, flatten_errors}; use crate::util::{Merging, Plural, Required, Resolving}; -// TODO: implement Float / Integer, and deal with regularizing that -// to float64 only when we serialize to JSON (but still enforce the -// boundary on integers in the same place we do now) +// +// ---------------- `Value` ---------------- +// + +/// `Value` is an expressive type that can be used to represent any TOML / JSON object with +/// one more expressions in them. Crucially, it implements the `Expanding` trait, which +/// allows those expressions to be expanded into `Value`'s themselves. Values are used +/// to represent parsed TOML data, expand the expressions in them, and translate +/// those values to JSON and/or Rhai `Dynaamic` objects. + #[derive(Deserialize, Serialize, Debug, Clone, PartialEq)] #[serde(try_from = "toml::Value")] pub enum Value { @@ -33,7 +31,7 @@ pub enum Value { String(String), Boolean(bool), Array(Vec), - Table(IndexMap), + Table(BTreeMap), Interp(Vec), // TODO: could optimize further by using an internned string (simplifying AST lookup) // TODO: include a span so that we can improve error messages @@ -82,7 +80,7 @@ impl TryFrom for Value { .clone() .into_iter() .map(|(k, v)| Ok((k.as_str().to_string(), Value::try_from(v.to_owned())?))) - .collect::>>()?; + .collect::>>()?; return Ok(Value::Table(values)); } else if value.is_bool() { return Ok(Value::Boolean(value.as_bool().expect("boolean"))); @@ -174,6 +172,27 @@ fn string_to_expression(x: String) -> Value { return Value::Interp(interps); } +impl From for toml::Value { + fn from(value: Value) -> toml::Value { + return match value { + Value::Expression(x) => panic!("Unresolved expression {x}"), + Value::Interp(interps) => panic!("Unresolved interpolation {interps:?}"), + Value::Array(items) => { + let new_items = items.into_iter().map(|it| it.into()).collect(); + toml::Value::Array(new_items) + } + Value::Table(kv) => { + let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); + toml::Value::Table(new_kv) + } + Value::Boolean(x) => toml::Value::Boolean(x), + Value::Float(x) => toml::Value::Float(x), + Value::Integer(x) => toml::Value::Integer(x as i64), + Value::String(x) => toml::Value::String(x), + }; + } +} + impl Merging for Value { fn coalesce(self, new: Self) -> Self { return new; @@ -206,13 +225,42 @@ impl Merging for Value { } } +impl Resolving for Value { + fn resolve(self, _name: impl Into) -> ResultVec { + Ok(self) + } +} + +impl Resolving for Value { + fn resolve(self, name: impl Into) -> ResultVec { + self.require_constant().context_str(name)?; + return Ok(self.into()); + } +} + +// +// ---------------- `Expanding` trait ---------------- +// + +/// The `Expanding` trait is used to expand expressions contained within an object +/// into `Value`s. Any type that contains one or more `Value`'s should implement `Expanding` +/// so that the `Value` can be expanded. + pub trait Expanding { + /// `map_expressions` is used to expand expressions. On each call to the function `f` + /// the string inside the curly braces of an expression is passed, and `f` should return + /// a `Value`. If `f` doesn't know how to translate the given expression, it can bypass + /// evaluation by returning a `Value::Expression` containing the passed expression. fn map_expressions(self, f: &mut F) -> ResultVec where Self: Sized, F: FnMut(String) -> Result; + /// returns true if there are no `Value::Expression` enum variants in any contained + /// `Value` fn is_constant(&self) -> bool; + /// returns an `Err` if there are any `Value::Expression` enum variants in any + /// contained `Value`. fn require_constant(&self) -> ResultVec<()> where Self: Sized + Clone, @@ -224,7 +272,7 @@ pub trait Expanding { } } -impl Expanding for IndexMap { +impl Expanding for BTreeMap { fn is_constant(&self) -> bool { self.values().all(|v| v.is_constant()) } @@ -285,40 +333,99 @@ impl Expanding for Value { } } -impl From for toml::Value { - fn from(value: Value) -> toml::Value { - return match value { - Value::Expression(x) => panic!("Unresolved expression {x}"), - Value::Interp(interps) => panic!("Unresolved interpolation {interps:?}"), - Value::Array(items) => { - let new_items = items.into_iter().map(|it| it.into()).collect(); - toml::Value::Array(new_items) - } - Value::Table(kv) => { - let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); - toml::Value::Table(new_kv) - } - Value::Boolean(x) => toml::Value::Boolean(x), - Value::Float(x) => toml::Value::Float(x), - Value::Integer(x) => toml::Value::Integer(x as i64), - Value::String(x) => toml::Value::String(x), - }; +// expansion for other kinds of types +impl Expanding for Spanned { + fn is_constant(&self) -> bool { + self.as_ref().is_constant() + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + let span = self.span(); + Ok(Spanned::new( + span.clone(), + self.into_inner().map_expressions(f).context_range(&span)?, + )) } } -impl Resolving for Value { - fn resolve(self, _name: impl Into) -> ResultVec { - Ok(self) +impl Expanding for Vec { + fn is_constant(&self) -> bool { + self.iter().all(|x| x.is_constant()) + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + Ok(flatten_errors( + self.into_iter().map(|x| x.map_expressions(f)), + )?) } } -impl Resolving for Value { - fn resolve(self, name: impl Into) -> ResultVec { - self.require_constant().context_str(name)?; - return Ok(self.into()); +impl Expanding for Plural { + fn is_constant(&self) -> bool { + match self { + Plural::Zero => true, + Plural::One(x) => x.is_constant(), + Plural::Many(xs) => xs.iter().all(|x| x.is_constant()), + } + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + Ok(match self { + Plural::Zero => self, + Plural::One(x) => Plural::One(x.map_expressions(f)?), + Plural::Many(items) => Plural::Many(items.map_expressions(f)?), + }) + } +} + +impl Expanding for Required { + fn is_constant(&self) -> bool { + match self { + Required::DefaultValue => true, + Required::Value(x) => x.is_constant(), + } + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + return Ok(match self { + Required::DefaultValue => self, + Required::Value(x) => Required::Value(x.map_expressions(f)?), + }); + } +} + +impl Expanding for Option { + fn is_constant(&self) -> bool { + match self { + None => true, + Some(x) => x.is_constant(), + } + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(String) -> Result, + { + return Ok(match self { + None => self, + Some(x) => Some(x.map_expressions(f)?), + }); } } +// +// ---------------- `TypedValue` objects ---------------- +// + +/// A `TypedValue` wraps `Value`, requiring it to evaluate to an object that can be +/// converted into the given type `T`. #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)] #[serde(try_from = "toml::Value")] pub enum TypedValue @@ -466,90 +573,3 @@ impl Merging for TypedValue { return new; } } - -// expansion for other kinds of types -impl Expanding for Spanned { - fn is_constant(&self) -> bool { - self.as_ref().is_constant() - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - let span = self.span(); - Ok(Spanned::new( - span.clone(), - self.into_inner().map_expressions(f).context_range(&span)?, - )) - } -} - -impl Expanding for Vec { - fn is_constant(&self) -> bool { - self.iter().all(|x| x.is_constant()) - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - Ok(flatten_errors( - self.into_iter().map(|x| x.map_expressions(f)), - )?) - } -} - -impl Expanding for Plural { - fn is_constant(&self) -> bool { - match self { - Plural::Zero => true, - Plural::One(x) => x.is_constant(), - Plural::Many(xs) => xs.iter().all(|x| x.is_constant()), - } - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - Ok(match self { - Plural::Zero => self, - Plural::One(x) => Plural::One(x.map_expressions(f)?), - Plural::Many(items) => Plural::Many(items.map_expressions(f)?), - }) - } -} - -impl Expanding for Required { - fn is_constant(&self) -> bool { - match self { - Required::DefaultValue => true, - Required::Value(x) => x.is_constant(), - } - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - return Ok(match self { - Required::DefaultValue => self, - Required::Value(x) => Required::Value(x.map_expressions(f)?), - }); - } -} - -impl Expanding for Option { - fn is_constant(&self) -> bool { - match self { - None => true, - Some(x) => x.is_constant(), - } - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(String) -> Result, - { - return Ok(match self { - None => self, - Some(x) => Some(x.map_expressions(f)?), - }); - } -} diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 7ae99b35..e4ddff70 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1,7 +1,20 @@ +/// +/// @file bindings/index.md +/// @order -10 +/// +/// # Master Keybindings +/// +/// This defines version 2.0 of the master keybinding file format. +/// +/// Master keybindings are [TOML](https://toml.io/en/) files composed of the following +/// top-level fields: +/// +/// // top-level parsing of an entire file -use crate::bind::{Binding, BindingInput, Scope}; +use crate::bind::{Binding, BindingInput}; use crate::define::{Define, DefineInput}; -use crate::error::{self, ErrorContext, ErrorReport, ResultVec, flatten_errors}; +use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; +use crate::expression::Scope; use serde::{Deserialize, Serialize}; use toml::Spanned; @@ -14,11 +27,11 @@ struct KeyFileInput { bind: Option>>, } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Serialize)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct KeyFile { - pub define: Define, + define: Define, pub bind: Vec, } @@ -49,6 +62,7 @@ impl KeyFile { }; let mut scope = Scope::new(); + define.add_to_scope(&mut scope); let _ = scope .parse_asts(&bind_input) .map_err(|mut es| errors.append(&mut es.errors)); @@ -123,7 +137,7 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { #[cfg(test)] mod tests { use super::*; - use indexmap::IndexMap; + use std::collections::BTreeMap; use test_log::test; #[test] @@ -183,7 +197,7 @@ mod tests { assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, - Value::Table(IndexMap::from([ + Value::Table(BTreeMap::from([ ("a".into(), Value::Integer(1)), ("b".into(), Value::Expression("var.foo_string".into())), ])) @@ -224,7 +238,7 @@ mod tests { assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, - Value::Table(IndexMap::from([ + Value::Table(BTreeMap::from([ ("a".into(), Value::Integer(1)), ("b".into(), Value::Expression("var.foo_string".into())), ])) @@ -257,7 +271,7 @@ mod tests { ); assert_eq!( result.bind[i].commands[0].args, - Value::Table(IndexMap::from([( + Value::Table(BTreeMap::from([( "value".to_string(), Value::String(expected_value[i].clone()) ),])) diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 1a4b2adf..64ebc0ad 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,7 +1,7 @@ // error reporting -pub mod error; +mod error; +mod expression; mod util; -mod value; // [[bind]] level parsing mod bind; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index edc0bd3c..f911e912 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,8 +1,8 @@ use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, flatten_errors}; -use indexmap::IndexMap; use log::info; use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; use toml::{Spanned, Value}; pub trait Merging { @@ -27,7 +27,7 @@ impl Merging for toml::Table { } } -impl Merging for IndexMap { +impl Merging for BTreeMap { fn coalesce(self, new: Self) -> Self { return new; } From fb2fbe1f2d101c1a74b79b062ac4df6f6a9ecc0a Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 14 Sep 2025 00:31:02 -0400 Subject: [PATCH 47/79] updated documentation and doc build Created using spr 1.3.6-beta.1 --- docs/.gitignore | 5 +- mise.toml | 26 ++-- notes.md | 14 +- package.json | 2 +- pnpm-lock.yaml | 10 +- {docs/templates => src/docs}/guide.md | 0 {docs => src/docs}/index.md | 0 src/extension/keybindings/parsing.ts | 170 ----------------------- src/rust/parsing/src/bind.rs | 72 ++++++---- src/rust/parsing/src/bind/foreach.rs | 15 +- src/rust/parsing/src/define.rs | 20 +-- src/rust/parsing/src/expression.rs | 47 +++++-- src/rust/parsing/src/expression/value.rs | 27 ++-- src/rust/parsing/src/file.rs | 75 +++++++++- src/rust/parsing/src/lib.rs | 7 +- src/rust/parsing/src/util.rs | 156 ++++++++++----------- 16 files changed, 298 insertions(+), 348 deletions(-) rename {docs/templates => src/docs}/guide.md (100%) rename {docs => src/docs}/index.md (100%) diff --git a/docs/.gitignore b/docs/.gitignore index 759634e1..91170453 100644 --- a/docs/.gitignore +++ b/docs/.gitignore @@ -1,7 +1,4 @@ .vitepress/commands.mjs -commands/* .vitepress/bindings.mjs -bindings/* -expressions/* -guide.md .vitepress/dist/** +**/*.md diff --git a/mise.toml b/mise.toml index 6550e87f..f0c775cf 100644 --- a/mise.toml +++ b/mise.toml @@ -133,21 +133,29 @@ depends = ['build', 'build-tests'] run = 'pnpm exec playwright test' [tasks.extract-docs] -sources = ['README.md', 'src/extension/**/*.ts', 'docs/templates/**/*.md'] -outputs = { auto = true } -run = 'simple-src-docs -d docs src README.md docs/templates' +sources = ['README.md', 'src/extension/**/*.ts', 'src/rust/**/*.rs', 'src/docs/**/*.md'] +outputs = ['docs/**/*.md'] +run = ['simple-src-docs -d docs src README.md', 'cp src/docs/index.md docs/'] + +[tasks.dev-docs] +depends = ['extract-docs'] +run = 'pnpm exec vitepress dev docs' [tasks.build-docs] -sources = [ - 'docs/index.md', - 'docs/guide.md', - 'docs/bindings/**/*.md', - 'docs/commands/**/*.md', -] +sources = ['docs/**/*.md'] outputs = ['docs/.vitepress/dist/**/*'] depends = ['extract-docs'] run = 'pnpm exec vitepress build docs' +[tasks.clean-docs] +shell = 'nu -c' +run = ''' +let to_remove = glob docs/**/*.md +if not ($to_remove | is-empty) { + rm ...$to_remove +} +''' + [tasks.report-coverage] depends = ['test --coverage', 'test-integration'] run = ['c8 report -r html', 'http-server coverage'] diff --git a/notes.md b/notes.md index a7b90bea..951a0d23 100644 --- a/notes.md +++ b/notes.md @@ -143,21 +143,24 @@ Integration test debugging: - [X] foreach - [ ] error - [X] expression - - [ ] file - - [ ] lib - - [ ] util + - [X] file + - [X] lib + - [~] util - [X] replace IndexMap with BTreeMap - [X] update documentation of `bind`, `define` and `expressions` - - [ ] update documentation rendering pipeline - - [ ] fix and test command queues implementation (avoid so much copying) + - [X] refactor plural to use `into` / `from` Vec + - [X] update documentation rendering pipeline - [ ] error reporting is still a little finicky - [ ] could probably make what is part of the same error more explicit - [ ] reduce types of errors and tie error message string more explicitly to name of enum variant + - [ ] fix and test command queues implementation (avoid so much copying) + - [ ] re-run tests - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` - [ ] improve expression evaluation - [ ] support expressions in `foreach` resolution + - [ ] check if each AST has a `foreach` variable and resolve it - [ ] allow for `var` evaluation in parse-time expressions - [ ] move all bare variables in an expression to `code.` object - [ ] implement support for `all` functions: @@ -166,6 +169,7 @@ Integration test debugging: - [ ] `{{all_modes_but(["not_me", "or_me"])}}` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field + - [ ] support `skipWhen` - [ ] flatten all nested `runCommands` calls - [ ] `skipWhen` will have to be propagated/merged to children - [ ] check constraints diff --git a/package.json b/package.json index 2a7c4283..889670b7 100644 --- a/package.json +++ b/package.json @@ -237,7 +237,7 @@ "type-fest": "^4.41.0", "typescript": "^5.8.3", "typescript-eslint": "^8.35.1", - "vitepress": "^1.6.3", + "vitepress": "^1.6.4", "vscode-uri": "^3.1.0", "zod": "^3.25.67", "zod-validation-error": "^3.5.2" diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 0539f329..bf0dc957 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -123,8 +123,8 @@ importers: specifier: ^8.35.1 version: 8.35.1(eslint@9.30.1)(typescript@5.8.3) vitepress: - specifier: ^1.6.3 - version: 1.6.3(@algolia/client-search@5.30.0)(@types/node@24.0.10)(postcss@8.5.6)(search-insights@2.17.3)(typescript@5.8.3) + specifier: ^1.6.4 + version: 1.6.4(@algolia/client-search@5.30.0)(@types/node@24.0.10)(postcss@8.5.6)(search-insights@2.17.3)(typescript@5.8.3) vscode-uri: specifier: ^3.1.0 version: 3.1.0 @@ -3037,8 +3037,8 @@ packages: terser: optional: true - vitepress@1.6.3: - resolution: {integrity: sha512-fCkfdOk8yRZT8GD9BFqusW3+GggWYZ/rYncOfmgcDtP3ualNHCAg+Robxp2/6xfH1WwPHtGpPwv7mbA3qomtBw==} + vitepress@1.6.4: + resolution: {integrity: sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==} hasBin: true peerDependencies: markdown-it-mathjax3: ^4 @@ -6327,7 +6327,7 @@ snapshots: '@types/node': 24.0.10 fsevents: 2.3.3 - vitepress@1.6.3(@algolia/client-search@5.30.0)(@types/node@24.0.10)(postcss@8.5.6)(search-insights@2.17.3)(typescript@5.8.3): + vitepress@1.6.4(@algolia/client-search@5.30.0)(@types/node@24.0.10)(postcss@8.5.6)(search-insights@2.17.3)(typescript@5.8.3): dependencies: '@docsearch/css': 3.8.2 '@docsearch/js': 3.8.2(@algolia/client-search@5.30.0)(search-insights@2.17.3) diff --git a/docs/templates/guide.md b/src/docs/guide.md similarity index 100% rename from docs/templates/guide.md rename to src/docs/guide.md diff --git a/docs/index.md b/src/docs/index.md similarity index 100% rename from docs/index.md rename to src/docs/index.md diff --git a/src/extension/keybindings/parsing.ts b/src/extension/keybindings/parsing.ts index 2cc2a8b9..4c3f30a1 100644 --- a/src/extension/keybindings/parsing.ts +++ b/src/extension/keybindings/parsing.ts @@ -15,90 +15,6 @@ export const INPUT_CAPTURE_COMMANDS = [ 'search', ]; -/** - * @file bindings/index.md - * @order -10 - * - * # Master Keybindings - * - * This defines version 2.0 of the master keybinding file format. - * - * Master keybindings are [TOML](https://toml.io/en/) files composed of the following - * top-level fields: - * - */ - -/** - * @file bindings/index.md - * @order 50 - * - * Here's a minimal example, demonstrating the most basic use of each field - * - * ```toml - * [header] - * # this denotes the file-format version, it must be semver compatible with 2.0 - * version = "2.0" - * name = "My Bindings" - * - * [[mode]] - * name = "insert" - * - * [[mode]] - * name = "normal" - * default = true - * - * [[kind]] - * name = "motion" - * description = "Commands that move your cursor" - * - * [[kind]] - * name = "mode" - * description = "Commands that change the keybinding mode" - * - * [[bind]] - * key = "i" - * name = "insert" - * mode = "normal" - * command = "master-key.enterInsert" - * kind = "mode" - * - * [[bind]] - * key = "escape" - * name = "normal" - * mode = "insert" - * command = "master-key.enterNormal" - * kind = "mode" - * - * [[default]] - * id = "basic_motion" - * name = "Motion Keys" - * default.mode = "normal" - * default.kind = "motion" - * default.command = "cursorMove" - * - * [[bind]] - * name = "right" - * defaults = "basic_motion" - * key = "l" - * args.to = "right" - * - * [[bind]] - * name = "left" - * defaults = "basic_motion" - * key = "h" - * args.to = "left" - * - * [define] - * foo = 1 - * - * [[bind]] - * name = "double right" - * key = "g l" - * defaults = "basic_motion" - * args.to = "right" - * computedArgs.value = "foo+1" - * ``` - */ /** * @bindingField header @@ -659,92 +575,6 @@ export const bindingSpec = z. } return xs; }), - /** - * @bindingField define - * @description object of arbitrary fields which can be used in computed arguments. - * - * The `define` field accepts an arbitrary set of key-value pairs - * that can be referenced inside an [expression](/expressions/index) - * or a call to "runCommands". - * - * **Examples** - * - * A common command pattern in Larkin is to allow multiple lines to be - * selected using a count followed by the operation to perfrom on those lines. - * The line selection is defined as follows - * - * ```toml - * [[define.selectLinesDown]] - * command = "selection-utilities.shrinkToActive" - * - * [[define.selectLinesDown]] - * whenComputed = "count" - * command = "cursorMove" - * args = { to = "down", by = "wrappedLine", select = true } - * computedArgs = { value = "count" } - * - * [[define.selectLinesDown]] - * command = "expandLineSelection" - * ``` - * - * And use of this definition is as follows - * - * ```toml - * [[bind]] - * defaults = "edit.action.basic" - * key = "c" - * when = "!editorHasSelection && master-key.count > 1" - * command = "runCommands" - * args.commands = [ - * { defined = "selectLinesDown" }, - * "deleteRight", - * "editor.action.insertLineBefore", - * "master-key.enterInsert", - * ] - * ``` - * - * To handle symmetric insert of brackets, Larkin uses the following definition - * - * ```toml - * [define.braces] - * - * "{".before = "{" - * "{".after = "}" - * "}".before = "{" - * "}".after = "}" - * - * "[".before = "[" - * "[".after = "]" - * "]".before = "[" - * "]".after = "]" - * - * "(".before = "(" - * "(".after = ")" - * ")".before = "(" - * ")".after = ")" - * - * "<".before = "<" - * "<".after = ">" - * ">".before = "<" - * ">".after = ">" - * ``` - * - * This is then applied when handling symmetric typing using the - * [`onType`](/bindings/mode#ontype-field) field of `[[mode]]`. - * - * ```toml - * [[mode]] - * name = "syminsert" - * highlight = "Highlight" - * cursorShape = "BlockOutline" - * - * [[mode.onType]] - * command = "selection-utilities.insertAround" - * computedArgs.before = "braces[captured].before || captured" - * computedArgs.after = "braces[captured].after || captured" - * args.followCursor = true - * ``` - */ define: z.record(z.string(), z.any()).optional().default({}), }). diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 0e6c0ee3..53aecbda 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -23,18 +23,18 @@ use crate::util::{Merging, Plural, Required, Resolving}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; fn default_mode() -> Spanned>> { - return Spanned::new( - UNKNOWN_RANGE, - Plural::One(TypedValue::Constant("default".into())), - ); + return Spanned::new(UNKNOWN_RANGE, Plural::default()); } fn span_required_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Required::DefaultValue); } -fn span_plural_default() -> Spanned> { - return Spanned::new(UNKNOWN_RANGE, Plural::Zero); +fn span_plural_default() -> Spanned> +where + T: Clone, +{ + return Spanned::new(UNKNOWN_RANGE, Plural::default()); } // @@ -58,12 +58,22 @@ fn span_plural_default() -> Spanned> { /// - ❗ denotes a required field. /// - ⚡ denotes that a field can include runtime [expressions](/expressions/index) /// +/// ## Fields +/// #[derive(Deserialize, Clone, Debug)] pub struct BindingInput { // implementation detail of `BindingInput`: this field should only be `Some` when used // as a part of an entry to `Define`. It is removed downstream using `without_id`. pub(crate) id: Option>, + /// @forBindingField bind + /// + /// - ❗`key`: the + /// [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that + /// triggers `command`. + #[serde(default = "span_required_default")] + pub key: Spanned>, + /// @forBindingField bind /// /// - ❗`command`: A string denoting the command to execute. This is a command defined by @@ -80,14 +90,6 @@ pub struct BindingInput { #[serde(default)] pub args: Option>, - /// @forBindingField bind - /// - /// - ❗`key`: the - /// [keybinding](https://code.visualstudio.com/docs/getstarted/keybindings) that - /// triggers `command`. - #[serde(default = "span_required_default")] - pub key: Spanned>, - /// @forBindingField bind /// /// - `when`: A [when clause](https://code.visualstudio.com/api/references/when-clause-contexts) @@ -114,7 +116,7 @@ pub struct BindingInput { /// @forBindingField bind /// /// - `default`: the default values to use for fields, specified as - /// string of the form `{{bind.[name]}}`. + /// string of the form `{{bind.[name]}}`. /// See [`define`](/bindings/define) for more details. #[serde(default)] pub default: Option>, @@ -128,7 +130,7 @@ pub struct BindingInput { /// @forBindingField bind /// /// - `prefixes`: array of strings or an expression of producing such an array. - /// (see also [`all_prefixes`](expressions/functions#all_prefixes). + /// (see also [`all_prefixes`](expressions/functions#all_prefixes)). /// The prefixes determine one or more *unresolved* key /// sequences that can have occurred before typing this key. See /// [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. @@ -151,12 +153,14 @@ pub struct BindingInput { /// /// - ⚡ `repeat`: The number of times to repeat the command; this can be a runtime /// [expression](/expressions/index). This defaults to zero: one repeat means the - /// command is run twice. + /// command is run twice. The most common use case here is to set this to `'{{key.count}}'` for a command that does not accept a count value as + /// an argument. repeat: Option>>, /// @forBindingField bind /// - /// - `doc`: Documentation for this keybinding, none of the fields of this object + /// - `doc`: Documentation for this keybinding. None of the fields of this object /// impact the behavior of the keybinding, only the interactive documentation /// features describing keybindings. doc: Option, @@ -190,8 +194,17 @@ pub struct BindingInput { /// Each keybinding can make use of any context defined in VSCode across any extension. /// Master Key adds the follow contexts: /// -/// - All variables available to an [expression](/expressions/index), prefixed with -/// `master-key.` +/// - `master-key.mode`: the current keybinding mode +/// - `master-key.count`: The current count, as defined by +/// [`master-key.updateCount`](/commands/updateCount) +/// - `master-key.captured`: The text currently captured by the most recent call to +/// [`master-key.restoreNamed`](/commands/restoreNamed) or +/// [`master-key.captureKeys`](/commands/captureKeys). +/// - `master-key.prefix`: The currently active [keybinding prefix](/commands/prefix) +/// - `master-key.record`: a boolean flag used to indicate when keys are marked for +/// recording +/// - `master-key.var.[name]`: the current value of a +/// [defined variable](/bindings/define#variable-definitions). /// - `master-key.keybindingPaletteBindingMode`: true when the suggestion palette accepts /// keybinding key presses, false it accepts a string to search the descriptions of said /// keybindings @@ -291,7 +304,7 @@ impl Expanding for BindingInput { }), mode: self.mode.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Plural::Zero) + Spanned::new(UNKNOWN_RANGE, Plural::default()) }), priority: self.priority.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -303,7 +316,7 @@ impl Expanding for BindingInput { }), prefixes: self.prefixes.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Plural::Zero) + Spanned::new(UNKNOWN_RANGE, Plural::default()) }), finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -649,10 +662,11 @@ mod tests { let foreach = result.foreach.unwrap(); let values = foreach.get("index").unwrap(); let numbers: Vec = values.iter().map(|it| it.clone().into_inner()).collect(); - assert_eq!( - numbers, - [Value::Integer(1), Value::Integer(2), Value::Integer(3)] - ); + assert_eq!(numbers, [ + Value::Integer(1), + Value::Integer(2), + Value::Integer(3) + ]); assert_eq!(when, "joe > 1".to_string()); let prefixes: Vec = result @@ -715,10 +729,8 @@ mod tests { )])) ); - assert_eq!( - String::from(result.mode.into_inner().to_array().first().unwrap().clone()), - "default".to_string() - ); + let modes: Vec = result.mode.resolve("`mode` field").unwrap(); + assert_eq!(modes.first(), "default".to_string()); assert_eq!(result.combinedDescription, None); assert_eq!(result.combinedName, None); } diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index c4a5988b..4760edcc 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -5,10 +5,10 @@ /// /// The `bind.foreach` field of a keybinding can be used to generate many bindings from one /// entry. Each field under `foreach` is looped through exhaustively. On each iteration, any -/// expressions with `foreach` defined variables are replaced with those variables' values -/// for the given iteration. For example, the following defines 9 bindings: +/// [expressions](/expressions/index) with `foreach` defined variables are replaced with those variables' values +/// for the given iteration. Any expression containing a `foreach` defined variable is +/// resolved at parse-time. For example, the following defines 9 bindings: /// -/// ::: v-pre /// ```toml /// [[bind]] /// foreach.a = [1,2,3] @@ -17,17 +17,15 @@ /// command = "type" /// args.text = "{{a-b}}" /// ``` -/// ::: /// -/// Furthermore, if the expression {{keys(`[regex]`)}} is included in a -/// `foreach` value, it is expanded to all keybindings that match the given regular +/// Furthermore, if the expression {{keys([quoted-regex])}} is included +/// in a `foreach` value, it is expanded to all keybindings that match the given regular /// expression and spliced into the array of values. For example, the following definition /// is used in `Larkin` to allow the numeric keys to be used as count prefix for motions. /// -/// ::: v-pre /// ```toml /// [[bind]] -/// foreach.num = ['{{key(`[0-9]`)}}'] # matches all numeric keybindings +/// foreach.num = ['{{keys(`[0-9]`)}}'] # matches all numeric keybindings /// name = "count {{num}}" /// key = "{{num}}" /// command = "master-key.updateCount" @@ -35,7 +33,6 @@ /// args.value = "{{num}}" /// # etc... /// ``` -/// ::: use crate::bind::BindingInput; use lazy_static::lazy_static; diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 593c8b10..af73b7e9 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -22,7 +22,7 @@ use crate::util::{Merging, Resolving}; /// computed arguments. /// /// The `define` field can be used to define re-usable values. There are three types of -/// values that be defined. +/// values that can be defined. /// /// 1. `[[define.var]]:` variable definitions: defines any number of key-value pairs that can /// be referenced inside an [expression](/expressions/index) @@ -33,13 +33,14 @@ use crate::util::{Merging, Resolving}; /// #[derive(Deserialize, Clone, Debug, Default)] pub struct DefineInput { - /// @bindingField define + /// @forBindingField define /// /// ## Variable Definitions /// - /// These can be any arbitrary TOML values. You can define multiple variables within - /// each `[[define.var]]` element this way. These are then available in any expressions - /// evaluated at runtime. + /// These can be any arbitrary TOML value. You can define multiple variables within + /// each `[[define.var]]` element this way. These are then available in any + /// [expressions](/expressions/index) + /// evaluated at runtime and in [when clauses](/bindings/bind#available-when-contexts). /// /// ### Example /// @@ -85,7 +86,7 @@ pub struct DefineInput { /// args.followCursor = true /// ``` pub var: Option>>>, - /// @bindingField define + /// @forBindingField define /// /// ## Command Definitions /// @@ -93,7 +94,7 @@ pub struct DefineInput { /// [running multiple commands](/bindings/bind#running-multiple-commands). /// /// In addition the normal fields of a command, you must provide an `id` to refer to the - /// command as `{{command.[id]}}`. + /// command as `{{command.[id]}}`. /// /// ### Example /// @@ -126,7 +127,7 @@ pub struct DefineInput { /// ] /// ``` pub command: Option>>, - /// @bindingField define + /// @forBindingField define /// /// ## Binding Definitions /// @@ -162,6 +163,9 @@ pub struct DefineInput { /// args.to = "right" /// ``` /// + /// This example also demonstrates that `define.bind` definitions can themselves have + /// defaults, allowing for a hierarchy of defaults if so desired. + /// pub bind: Option>>, } diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index e7318c82..a518defa 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -19,16 +19,41 @@ use crate::{ /// /// You can use expressions in a number of places inside a [bind](/bindings/bind) /// definition. An expression is a snippet of code surrounded by double curly braces {{like + this}} that occurs within a TOML string. When the string begins -/// and ends with the curly braces of the expression that string can evaluate to any valid -/// TOML object. If there is additional text outside of the string, the expression will be -/// converted to a string and interpolated into the the surrounding text. +/// v-pre>{{like + this}} that occurs within a TOML string. Expressions can evaluate +/// to any valid TOML object when the entire string is an expression +/// +/// ```toml +/// [[define.var]] +/// action_priority = 3 +/// +/// [[bind]] +/// # ...other fields here... +/// priority = "{{var.action_priority + 2}}" +/// +/// # after expression evaluation, the above would evaluate to +/// priority = 5 +/// ``` +/// +/// If there is additional text in the string that falls outside of the expression, the +/// expression is interpolated into the string +/// +/// ```toml +/// [[define.var]] +/// action_priority = 3 +/// +/// [[bind]] +/// # ...other fields here... +/// name = "My cool action (priority {{var.action_priority + 2}})" +/// +/// # after expression evaluation, the above would evaluate to +/// name = "My cool action (priority 5)" +/// ``` /// /// Valid expressions are a simple subset of [Rhai](https://rhai.rs/book/ref/index.html). -/// You cannot execute statements, set variables, use loops, or define. If you find yourself -/// wanting to write an elaborate expression, your goal is probably better accomplished by -/// writing an [extension](https://code.visualstudio.com/api) and running the extension -/// defined command. +/// You cannot execute statements, set variables, use loops, or define functions. If you +/// find yourself wanting to write an elaborate expression, your goal is probably better +/// accomplished by writing an [extension](https://code.visualstudio.com/api) and running +/// the extension defined-command. /// /// There are two points at which an expression can be evaluated: while parsing the master /// keybinding file (e.g. making use of [foreach](/bindings/bind#foreach-clauses)) or at @@ -36,9 +61,9 @@ use crate::{ /// /// ## Parse-time Evaluation /// -/// Parse-time expressions improve expressivity of the keybinding spec. They are generally -/// quite limited in terms of what values are in scope within the expression. The individual -/// fields of `bind` document the scope of a given parse-time expression. +/// Parse-time expressions are generally quite limited in terms of what values are in scope +/// within the expression. The individual fields of `bind` document the scope of a given +/// parse-time expression. /// /// ## Run-time Evaluation /// diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 22fe3d5d..87640cae 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -1,13 +1,13 @@ #[allow(unused_imports)] use log::info; -use std::collections::BTreeMap; use lazy_static::lazy_static; use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; -use std::io; +use std::collections::BTreeMap; use std::io::Write; +use std::{default, io}; use toml::Spanned; use crate::error::{Error, ErrorContext, ErrorsWithContext, Result, ResultVec, flatten_errors}; @@ -364,23 +364,15 @@ impl Expanding for Vec { } } -impl Expanding for Plural { +impl Expanding for Plural { fn is_constant(&self) -> bool { - match self { - Plural::Zero => true, - Plural::One(x) => x.is_constant(), - Plural::Many(xs) => xs.iter().all(|x| x.is_constant()), - } + return self.0.is_constant(); } fn map_expressions(self, f: &mut F) -> ResultVec where F: FnMut(String) -> Result, { - Ok(match self { - Plural::Zero => self, - Plural::One(x) => Plural::One(x.map_expressions(f)?), - Plural::Many(items) => Plural::Many(items.map_expressions(f)?), - }) + return Ok(Plural(self.0.map_expressions(f)?)); } } @@ -436,6 +428,15 @@ where Constant(T), } +impl Default for TypedValue +where + T: Default + Serialize + std::fmt::Debug, +{ + fn default() -> Self { + return TypedValue::Constant(T::default()); + } +} + impl<'e, T> TryFrom for TypedValue where T: Deserialize<'e> + Serialize + std::fmt::Debug, diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index e4ddff70..9c07d12a 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -10,7 +10,78 @@ /// top-level fields: /// /// -// top-level parsing of an entire file + +// NOTE: .simple-src-docs.config.toml is setup to insert a list of +// bindings here, between the above text and the below example + +/// @file bindings/index.md +/// @order 50 +/// +/// Here's a minimal example, demonstrating the most basic use of each field +/// +/// ```toml +/// [header] +/// # this denotes the file-format version, it must be semver compatible with 2.0 +/// version = "2.0" +/// name = "My Bindings" +/// +/// [[mode]] +/// name = "insert" +/// +/// [[mode]] +/// name = "normal" +/// default = true +/// +/// [[kind]] +/// name = "motion" +/// description = "Commands that move your cursor" +/// +/// [[kind]] +/// name = "mode" +/// description = "Commands that change the keybinding mode" +/// +/// [[bind]] +/// key = "i" +/// doc.name = "insert" +/// mode = "normal" +/// command = "master-key.enterInsert" +/// doc.kind = "mode" +/// +/// [[bind]] +/// key = "escape" +/// doc.name = "normal" +/// mode = "insert" +/// command = "master-key.enterNormal" +/// doc.kind = "mode" +/// +/// [[define.bind]] +/// id = "basic_motion" +/// mode = "normal" +/// doc.kind = "motion" +/// command = "cursorMove" +/// +/// [[bind]] +/// doc.name = "right" +/// defaults = "{{basic_motion}}" +/// key = "l" +/// args.to = "right" +/// +/// [[bind]] +/// doc.name = "left" +/// defaults = "{{basic_motion}}" +/// key = "h" +/// args.to = "left" +/// +/// [[define.var]] +/// foo = 1 +/// +/// [[bind]] +/// doc.name = "double right" +/// key = "g l" +/// defaults = "{{basic_motion}}" +/// args.to = "right" +/// args.value = "{{foo+1}}" +/// ``` use crate::bind::{Binding, BindingInput}; use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; @@ -37,6 +108,7 @@ pub struct KeyFile { impl KeyFile { fn new(input: KeyFileInput) -> ResultVec { + // [[define]] let mut errors = Vec::new(); let define_input = input.define.unwrap_or_default(); let mut define = match Define::new(define_input) { @@ -47,6 +119,7 @@ impl KeyFile { Ok(x) => x, }; + // [[bind]] let input_iter = input .bind .into_iter() diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 64ebc0ad..e6750018 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -1,10 +1,11 @@ -// error reporting +// assorted utilities mod error; mod expression; mod util; -// [[bind]] level parsing +// define file sections mod bind; mod define; -// file level parsing + +// top level parsing pub mod file; diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index f911e912..67aedf1f 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,30 +1,35 @@ -use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, flatten_errors}; - +#[allow(unused_imports)] use log::info; + use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use toml::{Spanned, Value}; +use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, flatten_errors}; + +/// The `Merging` trait allows us to combine two versions of an object according to +/// two different approaches (`coalesce` or `merge`). pub trait Merging { - fn merge(self, new: Self) -> Self; + /// `coalesce` returns `new`, unless it is a `null`-like value, such as `None` + /// or `Required::DefaultValue` fn coalesce(self, new: Self) -> Self; + /// `merge` combines values, coalescing at the leaf values of containers, and + /// recursively calling `merge` for any items that share a key. The returned container + /// has all keys from self and all keys from new. + fn merge(self, new: Self) -> Self; } -// TODO: is there any way to avoid so much copying here impl Merging for toml::Table { - fn merge(self, mut new: Self) -> Self { - for (k, v) in self { - if new.contains_key(&k) { - new[&k] = v.merge(new[&k].clone()); - } else { - new.insert(k, v); - } - } - return new; - } fn coalesce(self, new: Self) -> Self { return new; } + fn merge(self, mut new: Self) -> Self { + let pairs = self.into_iter().map(|(k, v)| match new.remove(&k) { + Some(new_v) => (k, v.merge(new_v)), + None => (k, v), + }); + return pairs.collect(); + } } impl Merging for BTreeMap { @@ -32,14 +37,11 @@ impl Merging for BTreeMap { return new; } fn merge(self, mut new: Self) -> Self { - for (k, v) in self { - if new.contains_key(&k) { - new[&k] = v.merge(new[&k].clone()); - } else { - new.insert(k, v); - } - } - return new; + let pairs = self.into_iter().map(|(k, v)| match new.remove(&k) { + Some(new_v) => (k, v.merge(new_v)), + None => (k, v), + }); + return pairs.collect(); } } @@ -71,16 +73,20 @@ impl Merging for Required { } } -impl Merging for Plural { +impl Merging for Plural +where + T: Clone, +{ fn merge(self, _: Self) -> Self { panic!("Not yet implemented (we don't yet need this function)") } fn coalesce(self, new: Self) -> Self { - return match new { - Plural::Zero => self, - _ => new, - }; + if new.0.is_empty() { + return self; + } else { + return new; + } } } @@ -104,14 +110,14 @@ impl Merging for bool { } } +/// `Resolving` objects implement `resolve` which removes book-keeping objects related to +/// the parsing an object (e.g. toml::Span), and returns a more ergonomic object +/// representations useful for downstream operations that don't care about these +/// book-keeping objects. pub trait Resolving { fn resolve(self, name: impl Into) -> ResultVec; } -pub trait Requiring { - fn require(self, name: impl Into) -> Result; -} - impl Resolving for Spanned where T: Resolving, @@ -134,8 +140,14 @@ where } } -// required values are only required at the very end of parsing, once all known defaults -// have been resolved +impl Resolving for String { + fn resolve(self, _name: impl Into) -> ResultVec { + return Ok(self); + } +} + +/// required values represent a value that cannot be missing in a keybinding object after +/// resolving all user defined defaults. #[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] #[serde(untagged, try_from = "Option")] pub enum Required { @@ -205,72 +217,58 @@ impl Required { } } -impl Resolving for String { - fn resolve(self, name: impl Into) -> ResultVec { - return Ok(self); - } -} - // TODO: use `try_from` to improve error messages -#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] -#[serde(untagged)] -pub enum Plural { - #[default] - Zero, - One(T), - Many(Vec), -} +#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)] +#[serde(from = "Vec", into = "Vec")] +pub struct Plural(pub(crate) Vec) +where + T: Clone; -impl Plural> { - pub fn into_inner(self) -> Plural { - return match self { - Plural::Zero => Plural::Zero, - Plural::One(x) => Plural::One(x.into_inner()), - Plural::Many(xs) => Plural::Many(xs.into_iter().map(|x| x.into_inner()).collect()), - }; +impl From> for Plural +where + T: Clone, +{ + fn from(values: Vec) -> Self { + return Plural(values); } } -impl Plural { - pub fn to_array(self) -> Vec { - return match self { - Plural::Zero => Vec::new(), - Plural::One(val) => vec![val], - Plural::Many(vals) => vals, - }; +impl From for Plural +where + T: Clone, +{ + fn from(value: T) -> Self { + return Plural(vec![value]); } +} - pub fn map(self, f: F) -> Plural - where - F: Fn(&T) -> R, - { - return match self { - Plural::Zero => Plural::Zero, - Plural::One(x) => Plural::One(f(&x)), - Plural::Many(xs) => Plural::Many(xs.iter().map(f).collect()), - }; +impl Default for Plural +where + T: Clone, +{ + fn default() -> Self { + return Plural(vec![]); } } -impl Plural { - pub fn or(self, default: Plural) -> Plural { - return match self { - Plural::Zero => default, - _ => self, - }; +impl From> for Vec +where + T: Clone, +{ + fn from(value: Plural) -> Self { + return value.0; } } impl Resolving> for Plural where - T: Resolving + std::fmt::Debug, + T: Clone + Resolving + std::fmt::Debug, U: std::fmt::Debug, { fn resolve(self, name: impl Into) -> ResultVec> { - let vals = self.to_array(); let name = name.into(); Ok(flatten_errors( - vals.into_iter().map(|x| x.resolve(name.clone())), + self.0.into_iter().map(|x| x.resolve(name.clone())), )?) } } From 249bd6e18dfb63f6f88dd3843ada364263d2ab50 Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 14 Sep 2025 21:35:42 -0400 Subject: [PATCH 48/79] wip error propagation refactoring Created using spr 1.3.6-beta.1 --- notes.md | 3 +- src/rust/parsing/Cargo.lock | 1 + src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/src/bind/command.rs | 22 ++-- src/rust/parsing/src/bind/validation.rs | 16 +-- src/rust/parsing/src/define.rs | 14 +-- src/rust/parsing/src/error.rs | 140 ++++++++++++----------- src/rust/parsing/src/expression.rs | 21 ++-- src/rust/parsing/src/expression/value.rs | 17 +-- src/rust/parsing/src/util.rs | 6 +- 10 files changed, 126 insertions(+), 115 deletions(-) diff --git a/notes.md b/notes.md index 951a0d23..1000307b 100644 --- a/notes.md +++ b/notes.md @@ -206,7 +206,8 @@ Integration test debugging: - [ ] serialization of bindings to settings.json - [ ] create data types to generate warnings/hints for old/unused fields - [ ] test this on the old version of larkin.toml - - [ ] actually replace javascript behavior with rust functions + - [ ] actually replace javascript behavior with rust functions (replace `dod`) + - [ ] replace `setFlag` with `updateDefine` - [ ] CI - [x] setup CI unit tests for rust - [x] setup rust coverage diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 5b3d4d68..d7a61036 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -360,6 +360,7 @@ dependencies = [ "rhai", "serde", "serde-wasm-bindgen", + "smallvec", "string-offsets", "test-log", "thiserror", diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index f280fad4..259ccf4d 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -27,6 +27,7 @@ toml = { version = "0.9.2", features = ["preserve_order"] } wasm-bindgen = "0.2.100" wasm-bindgen-test = "0.3.50" instant = { version = "0.1.13", features = ["wasm-bindgen"] } +smallvec = "1.15.1" [lib] crate-type = ["cdylib"] diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 7406eb94..3437eda7 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -5,7 +5,7 @@ use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ bind::{BindingInput, UNKNOWN_RANGE}, - error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, constrain, reserved}, + error::{RawError, ErrorContext, Error, Result, ResultVec, constrain, reserved}, expression::Scope, expression::value::{Expanding, TypedValue, Value}, util::{Required, Resolving}, @@ -116,23 +116,23 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec kv .get("commands") .ok_or_else(|| { - Error::Constraint("`runCommands` must have `args.commands` field".into()) + RawError::Constraint("`runCommands` must have `args.commands` field".into()) })? .clone(), - _ => Err(Error::Validation( + _ => Err(RawError::Validation( "Expected `args` to be an object with `commands` field".to_string(), ))?, }; let command_vec = match commands { Value::Array(items) => items, - _ => Err(Error::Validation( + _ => Err(RawError::Validation( "Expected `args.commands` of `runCommands` to \ be a vector of commands to run." .to_string(), @@ -147,7 +147,7 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec { let result = kv.get("command").ok_or_else({ || { - Error::RequiredField( + RawError::RequiredField( "`args.commands.command` field for `runCommands`".into(), ) } @@ -155,19 +155,19 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec x.to_owned(), _ => { - let err: ErrorWithContext = - Error::Constraint("`command` to be a string".into()).into(); + let err: Error = + RawError::Constraint("`command` to be a string".into()).into(); Err(err).context_range(&args_pos)? } }; let result = kv.get("args").ok_or_else(|| { - Error::RequiredField("`args.commands.arg` field for `runCommands`".into()) + RawError::RequiredField("`args.commands.arg` field for `runCommands`".into()) })?; let args = match result { x @ Value::Table(_) => x, x @ Value::Array(_) => x, _ => { - return Err(Error::Constraint("`args` to be a table or array".into()))?; + return Err(RawError::Constraint("`args` to be a table or array".into()))?; } }; (command_name, args.to_owned()) @@ -202,7 +202,7 @@ impl Command { pub fn args(&self, scope: &mut Scope) -> ResultVec { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return match self.toml_args(scope)?.serialize(&to_json) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, Ok(x) => Ok(x), }; } diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 9c5d9f4e..3e05e288 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,4 +1,4 @@ -use crate::error::{Error, ErrorsWithContext, Result, ResultVec}; +use crate::error::{ErrorSet, RawError, Result, ResultVec}; use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; use crate::util::{Merging, Resolving}; @@ -105,11 +105,11 @@ fn valid_key_binding_str(str: &str) -> Result<()> { if first { first = false; if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { - return Err(Error::Validation(format!("key name {part}")))?; + return Err(RawError::Validation(format!("key name {part}")))?; } } else { if !MODIFIER_REGEX.is_match(part) { - return Err(Error::Validation(format!("modifier name {part}")))?; + return Err(RawError::Validation(format!("modifier name {part}")))?; } } } @@ -122,7 +122,7 @@ fn valid_key_binding_str(str: &str) -> Result<()> { pub struct KeyBinding(TypedValue); impl TryFrom for KeyBinding { - type Error = ErrorsWithContext; + type RawError = ErrorSet; fn try_from(value: String) -> ResultVec { if EXPRESSION.is_match(&value) { return Ok(KeyBinding(TypedValue::Variable( @@ -162,7 +162,7 @@ impl Expanding for KeyBinding { valid_key_binding_str(&val)?; KeyBinding(TypedValue::Constant(val)) } - other @ _ => return Err(Error::Unexpected("non-string value"))?, + other @ _ => return Err(RawError::Unexpected("non-string value"))?, }, }) } @@ -211,7 +211,7 @@ lazy_static! { pub struct BindingReference(pub(crate) String); impl TryFrom for BindingReference { - type Error = ErrorsWithContext; + type RawError = ErrorSet; fn try_from(value: String) -> ResultVec { let value: Value = toml::Value::String(value).try_into()?; match value { @@ -221,12 +221,12 @@ impl TryFrom for BindingReference { captures.get(1).expect("variable name").as_str().to_string(), )) } else { - Err(Error::Validation( + Err(RawError::Validation( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), ))? } } - _ => Err(Error::Validation( + _ => Err(RawError::Validation( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), ))?, } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index af73b7e9..20769dde 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -12,7 +12,7 @@ use toml::Spanned; use crate::bind::BindingInput; use crate::bind::command::CommandInput; use crate::bind::validation::BindingReference; -use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, unexpected}; +use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, unexpected}; use crate::expression::Scope; use crate::expression::value::{Expanding, Value}; use crate::util::{Merging, Resolving}; @@ -188,7 +188,7 @@ impl Define { let mut resolved_bind = HashMap::::new(); let mut resolved_command = HashMap::::new(); let mut resolved_var = HashMap::::new(); - let mut errors: Vec = Vec::new(); + let mut errors: Vec = Vec::new(); for def_block in input.var.into_iter().flatten() { for (var, value) in def_block.into_iter() { @@ -206,7 +206,7 @@ impl Define { for def in input.command.into_iter().flatten() { let id = def.get_ref().id.clone(); let span = id - .ok_or_else(|| Error::RequiredField("`id` field".into())) + .ok_or_else(|| RawError::RequiredField("`id` field".into())) .context_range(&def.span()); match span { Err(e) => errors.push(e.into()), @@ -224,7 +224,7 @@ impl Define { for def in input.bind.into_iter().flatten() { let id = def.get_ref().id.clone(); let span = id - .ok_or_else(|| Error::RequiredField("`id` field".into())) + .ok_or_else(|| RawError::RequiredField("`id` field".into())) .context_range(&def.span()); match span { Err(e) => errors.push(e.into()), @@ -270,7 +270,7 @@ impl Define { let BindingReference(name) = default.as_ref(); let entry = self.bind.entry(name.clone()); let occupied_entry = match entry { - hash_map::Entry::Vacant(_) => Err(Error::UndefinedVariable(name.clone()))?, + hash_map::Entry::Vacant(_) => Err(RawError::UndefinedVariable(name.clone()))?, hash_map::Entry::Occupied(entry) => entry, }; let mut default_value; @@ -293,12 +293,12 @@ impl Define { return Ok(self .command .get(name) - .ok_or_else(|| Error::UndefinedVariable(name.to_string()))? + .ok_or_else(|| RawError::UndefinedVariable(name.to_string()))? .without_id() .into()); } if BIND_REF.is_match(&exp) { - Err(Error::Constraint( + Err(RawError::Constraint( "`bind.` reference in `default` field only".into(), ))? } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 55c1ebb5..609c52ef 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,7 +1,8 @@ use crate::bind::UNKNOWN_RANGE; use core::ops::Range; -use rhai; +use rhai::{self, EvalAltResult}; +use smallvec::SmallVec; use std::fmt; use string_offsets::{Pos, StringOffsets}; use thiserror::Error; @@ -11,54 +12,41 @@ use wasm_bindgen::prelude::*; // TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) #[derive(Debug, Error, Clone)] -pub enum Error { - #[error("toml parsing {0}")] +pub enum RawError { + #[error("while parsing toml: {0}")] TomlParsing(#[from] toml::de::Error), - #[error("expression parsing {0}")] + #[error("while parsing expression: {0}")] ExpressionParsing(#[from] rhai::ParseError), - #[error("expression eval {0}")] - ExpressionEval(String), - #[error("serializing {0}")] + #[error("while writing toml: {0}")] Serialization(#[from] toml::ser::Error), - #[error("deserializing {0}")] - JsSerialization(String), - #[error("expression failed with {0}")] - Rhai(String), - #[error("invalid {0}")] - Validation(String), - #[error("expected {0}")] - Constraint(String), - #[error("requires {0}")] - RequiredField(String), - #[error("unexpected {0}")] - Unexpected(&'static str), - #[error("unresolved {0}")] - Unresolved(String), - #[error("undefined variable {0}")] - UndefinedVariable(String), - #[error("reserved field name {0}")] - ReservedField(&'static str), - #[error("parsing regex failed with {0}")] + #[error("while parsing regex: {0}")] Regex(#[from] regex::Error), + #[error("{0}")] + Static(&'static str), + #[error("{0}")] + Dynamic(String), } -// TODO: figure out how to expose errors in wasm -// (maybe we output some regular formatting structure rather than individual error types) #[wasm_bindgen] #[derive(Debug, Error, Clone)] -pub struct ErrorWithContext { +pub struct Error { #[source] - #[wasm_bindgen(skip)] - pub error: Error, - #[wasm_bindgen(skip)] - pub contexts: Vec, + pub(crate) error: RawError, + pub(crate) contexts: SmallVec<[String; 8]>, + pub(crate) ranges: SmallVec<[Position; 8]>, +} + +#[derive(Debug, Clone)] +enum Position { + Rhai(rhai::Position), + Range(Range), } #[wasm_bindgen] #[derive(Debug, Clone, Error)] #[error("first error: {}", .errors[0])] -pub struct ErrorsWithContext { - pub(crate) errors: Vec, +pub struct ErrorSet { + pub(crate) errors: Vec, } fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { @@ -67,21 +55,31 @@ fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { CharRange { start, end } } -impl From for ErrorsWithContext { - fn from(value: ErrorWithContext) -> Self { - return ErrorsWithContext { +// TODO: stopped working here +impl From> for Error { + fn from(value: Box) -> Self { + let error: Error = RawError::Dynamic(format!("{}", value)).into(); + // how to combine with info about surrounding range + // (if we have a range after this one use it; or should it be before?) + error.context_range(Position::Rhai(value.position())); + } +} + +impl From for ErrorSet { + fn from(value: Error) -> Self { + return ErrorSet { errors: vec![value], }; } } #[wasm_bindgen] -impl ErrorWithContext { +impl Error { pub fn report(&self, content: &[u8]) -> ErrorReport { let mut items = Vec::with_capacity(self.contexts.len() + 1); let offsets: StringOffsets = StringOffsets::from_bytes(content); items.push(match &self.error { - Error::TomlParsing(toml) => ErrorReportItem { + RawError::TomlParsing(toml) => ErrorReportItem { message: Some(toml.message().into()), range: toml.span().map(|r| range_to_pos(r, &offsets)), }, @@ -113,7 +111,7 @@ impl ErrorWithContext { } #[wasm_bindgen] -impl ErrorsWithContext { +impl ErrorSet { pub fn report(&self, content: &[u8]) -> Vec { return self.errors.iter().map(|e| e.report(content)).collect(); } @@ -133,7 +131,7 @@ where let flat_errs = errors .into_iter() .flat_map(|x| x.unwrap_err().errors.into_iter()) - .collect::>(); + .collect::>(); if flat_errs.len() > 0 { return Err(flat_errs.into()); @@ -162,8 +160,8 @@ pub enum Context { Range(Range), } -impl fmt::Display for ErrorWithContext { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::RawError> { for context in &self.contexts { match context { Context::String(str) => { @@ -179,51 +177,59 @@ impl fmt::Display for ErrorWithContext { } } -impl> From for ErrorWithContext { +impl> From for Error { fn from(error: E) -> Self { - return ErrorWithContext { + return Error { error: error.into(), - contexts: vec![], + contexts: SmallVec::new(), }; } } -impl> From for ErrorsWithContext { +impl From> for Error {} + +impl> From for ErrorSet { fn from(error: E) -> Self { + let error: RawError = error.into(); let error: Error = error.into(); - let error: ErrorWithContext = error.into(); return error.into(); } } -impl From> for ErrorsWithContext { - fn from(value: Vec) -> Self { - return ErrorsWithContext { errors: value }; +impl From> for ErrorSet { + fn from(value: Vec) -> Self { + return ErrorSet { errors: value }; } } pub fn constrain(msg: &str) -> Result { - return Err(Error::Constraint(msg.into()))?; + return Err(RawError::Constraint(msg.into()))?; } pub fn unexpected(msg: &'static str) -> Result { - return Err(Error::Unexpected(msg))?; + return Err(RawError::Unexpected(msg))?; } pub fn reserved(msg: &'static str) -> Result { - return Err(Error::ReservedField(msg))?; + return Err(RawError::ReservedField(msg))?; } +// TODO: range - we select the most narrowest error, or the first +// such error if some don't overlap +// TODO: keep context string +// when reporting we don't split single Error into +// multiple diagnostics + pub trait ErrorContext where Self: Sized, { - type Error; - fn context(self, context: Context) -> std::result::Result; - fn context_str(self, context: impl Into) -> std::result::Result { + type RawError; + fn context(self, context: Context) -> std::result::Result; + fn context_str(self, context: impl Into) -> std::result::Result { self.context(Context::String(context.into())) } - fn context_range(self, context: &impl Spannable) -> std::result::Result { + fn context_range(self, context: &impl Spannable) -> std::result::Result { if let Some(range) = context.range() { return self.context(Context::Range(range)); } else { @@ -254,12 +260,12 @@ impl Spannable for Range { } } -impl> ErrorContext for std::result::Result { - type Error = ErrorWithContext; +impl> ErrorContext for std::result::Result { + type RawError = Error; fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), - Err(e) => Err(ErrorWithContext { + Err(e) => Err(Error { error: e.into(), contexts: vec![context], }), @@ -268,13 +274,13 @@ impl> ErrorContext for std::result::Result { } impl ErrorContext for Result { - type Error = ErrorWithContext; + type RawError = Error; fn context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), Err(mut e) => { e.contexts.push(context); - Err(ErrorWithContext { + Err(Error { error: e.error, contexts: e.contexts, }) @@ -284,7 +290,7 @@ impl ErrorContext for Result { } impl ErrorContext for ResultVec { - type Error = ErrorsWithContext; + type RawError = ErrorSet; fn context(self, context: Context) -> ResultVec { return match self { Ok(x) => Ok(x), @@ -298,5 +304,5 @@ impl ErrorContext for ResultVec { } } -pub type Result = std::result::Result; -pub type ResultVec = std::result::Result; +pub type Result = std::result::Result; +pub type ResultVec = std::result::Result; diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index a518defa..9f096235 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -6,10 +6,11 @@ use std::collections::{HashMap, VecDeque}; use rhai::Dynamic; use serde::Serialize; +use toml::Spanned; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ - bind::command::Command, error::Error, error::Result, error::ResultVec, + bind::command::Command, error::RawError, error::Result, error::ResultVec, expression::value::Expanding, expression::value::Value, }; @@ -94,7 +95,7 @@ use crate::{ #[wasm_bindgen] pub struct Scope { - pub(crate) asts: HashMap, + pub(crate) asts: HashMap>, engine: rhai::Engine, pub(crate) state: rhai::Scope<'static>, pub(crate) queues: HashMap>, @@ -119,10 +120,10 @@ impl Scope { self.state.set_or_push(k, v.clone()); } return Ok(obj.clone().map_expressions(&mut |expr| { - let ast = &self.asts[&expr]; - let result = self.engine.eval_ast_with_scope(&mut self.state, &ast); + let ast = self.asts[&expr].get_ref(); + let result = self.engine.eval_ast_with_scope(&mut self.state, ast); let value: rhai::Dynamic = match result { - Err(x) => Err(Error::ExpressionEval(format!("{}", x)))?, + Err(x) => Err(RawError::ExpressionEval(format!("{}", x)))?, Ok(x) => x, }; let result_value: Value = value.clone().try_into()?; @@ -154,7 +155,7 @@ impl Scope { pub fn set(&mut self, name: String, value: JsValue) -> Result<()> { let toml: toml::Value = match serde_wasm_bindgen::from_value(value) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, Ok(x) => x, }; let val: Value = toml.try_into()?; @@ -167,22 +168,22 @@ impl Scope { return Ok(self .state .remove(&name) - .ok_or_else(|| Error::UndefinedVariable(name))?); + .ok_or_else(|| RawError::UndefinedVariable(name))?); } pub fn get(&self, name: String) -> Result { let x: &rhai::Dynamic = self .state .get(&name) - .ok_or_else(|| Error::UndefinedVariable(name))?; + .ok_or_else(|| RawError::UndefinedVariable(name))?; let x: Value = match x.clone().try_cast_result() { - Err(e) => Err(Error::Rhai(format!("{}", e)))?, + Err(e) => Err(RawError::Rhai(format!("{}", e)))?, Ok(x) => x, }; let x: toml::Value = x.into(); let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return match x.serialize(&to_json) { - Err(e) => Err(Error::JsSerialization(format!("{}", e)))?, + Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, Ok(x) => Ok(x), }; } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 87640cae..cfcf7857 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -6,11 +6,12 @@ use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; +use std::fmt::Display; use std::io::Write; use std::{default, io}; use toml::Spanned; -use crate::error::{Error, ErrorContext, ErrorsWithContext, Result, ResultVec, flatten_errors}; +use crate::error::{ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; use crate::util::{Merging, Plural, Required, Resolving}; // @@ -62,7 +63,7 @@ impl From for Dynamic { } impl TryFrom for Value { - type Error = crate::error::ErrorWithContext; + type RawError = crate::error::Error; // TODO: this is currently almost certainly quite inefficient (we clone arrays and // maps), but we can worry about optimizing this later fn try_from(value: Dynamic) -> Result { @@ -97,7 +98,7 @@ impl TryFrom for Value { .to_string(), )); } else { - Err(Error::Constraint(format!( + Err(RawError::Constraint(format!( "usable script value; but {value} is unusable" )))? } @@ -109,14 +110,14 @@ lazy_static! { } impl TryFrom for Value { - type Error = ErrorsWithContext; + type RawError = ErrorSet; fn try_from(value: toml::Value) -> ResultVec { return Ok(match value { toml::Value::Boolean(x) => Value::Boolean(x), toml::Value::Float(x) => Value::Float(x), toml::Value::Integer(x) => Value::Integer({ if x > (std::f64::MAX as i64) || x < (std::f64::MIN as i64) { - return Err(Error::Constraint(format!( + return Err(RawError::Constraint(format!( "{x} cannot be expressed as a 64-bit floating point number." )) .into()); @@ -266,7 +267,7 @@ pub trait Expanding { Self: Sized + Clone, { self.clone().map_expressions(&mut |e| { - Err(Error::Unresolved(format!("Unresolved expression {e}")).into()) + Err(RawError::Unresolved(format!("Unresolved expression {e}",)))? })?; return Ok(()); } @@ -441,13 +442,13 @@ impl<'e, T> TryFrom for TypedValue where T: Deserialize<'e> + Serialize + std::fmt::Debug, { - type Error = ErrorsWithContext; + type RawError = ErrorSet; fn try_from(value: toml::Value) -> ResultVec> { io::stdout().flush().unwrap(); let val: Value = value.try_into()?; io::stdout().flush().unwrap(); - return match val.require_constant() { + return match val.require_constant("") { Err(_) => Ok(TypedValue::Variable(val)), Ok(_) => { let toml: toml::Value = val.into(); diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 67aedf1f..904c1584 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use toml::{Spanned, Value}; -use crate::error::{Error, ErrorContext, ErrorWithContext, Result, ResultVec, flatten_errors}; +use crate::error::{RawError, ErrorContext, Error, Result, ResultVec, flatten_errors}; /// The `Merging` trait allows us to combine two versions of an object according to /// two different approaches (`coalesce` or `merge`). @@ -160,7 +160,7 @@ impl<'de, T> TryFrom> for Required where T: Deserialize<'de>, { - type Error = ErrorWithContext; + type RawError = Error; fn try_from(value: Option) -> Result { match value { None => Ok(Required::DefaultValue), @@ -175,7 +175,7 @@ where { fn resolve(self, name: impl Into) -> ResultVec { match self { - Required::DefaultValue => Err(Error::RequiredField(name.into()))?, + Required::DefaultValue => Err(RawError::RequiredField(name.into()))?, Required::Value(x) => x.resolve(name), } } From 5933f25f08583e195b096c20ef315d976ae20171 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 20 Sep 2025 08:18:47 -0400 Subject: [PATCH 49/79] cleanup error propagation Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 21 +- errors.txt | 433 ++++++++++++++++++++ mise.toml | 2 +- notes.md | 6 +- src/rust/parsing/errors.txt | 419 +++++++++++++++++++- src/rust/parsing/src/bind.rs | 245 ++++++------ src/rust/parsing/src/bind/command.rs | 55 ++- src/rust/parsing/src/bind/foreach.rs | 2 +- src/rust/parsing/src/bind/validation.rs | 31 +- src/rust/parsing/src/define.rs | 55 +-- src/rust/parsing/src/error.rs | 483 ++++++++++++++--------- src/rust/parsing/src/expression.rs | 40 +- src/rust/parsing/src/expression/value.rs | 89 +++-- src/rust/parsing/src/file.rs | 59 ++- src/rust/parsing/src/util.rs | 124 ++++-- 15 files changed, 1539 insertions(+), 525 deletions(-) create mode 100644 errors.txt diff --git a/.vscode/settings.json b/.vscode/settings.json index d37a7a58..773e16e4 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,8 +9,27 @@ "src/rust/parsing/Cargo.toml" ], "window.title": "vscode-master-key", - "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.88.0-aarch64-apple-darwin", + "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.89.0-aarch64-apple-darwin", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, + "workbench.colorCustomizations": { + "editorBracketHighlight.foreground1": "#1b9e77", + "editorBracketHighlight.foreground2": "#d95f02", + "editorBracketHighlight.foreground3": "#7570b3", + "editorBracketHighlight.foreground4": "#e7298a", + "editorBracketHighlight.foreground5": "#66a61e", + "editorBracketHighlight.foreground6": "#e6ab02", + "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", + "titleBar.activeBackground": "#f46558", + "titleBar.activeForeground": "#000000", + "titleBar.inactiveBackground": "#f46558", + "titleBar.inactiveForeground": "#000000", + "titleBar.border": "#f46558", + "activityBar.foreground": "#f46558", + "tab.activeBorder": "#f46558", + "iLoveWorkSpaceColors": true, + "iLoveWorkSpaceRandom": false, + "useWorkspaceLite": true + }, } diff --git a/errors.txt b/errors.txt new file mode 100644 index 00000000..6dad41fc --- /dev/null +++ b/errors.txt @@ -0,0 +1,433 @@ +[test-rust] $ def main [...args] { + Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) +warning: unused import: `RawError` + --> src/util.rs:9:41 + | +9 | use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, flatten_errors}; + | ^^^^^^^^ + | + = note: `#[warn(unused_imports)]` on by default + +warning: unused import: `crate::err` + --> src/bind/validation.rs:8:5 + | +8 | use crate::err; + | ^^^^^^^^^^ + +warning: unused import: `RawError` + --> src/bind/validation.rs:9:30 + | +9 | use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; + | ^^^^^^^^ + +error[E0308]: mismatched types + --> src/bind.rs:755:61 + | +755 | assert_eq!(result.doc.unwrap().combinedDescription, "".to_string()); + | ^^^^^^^^^^^^^^ expected `Option>>`, found `String` + | + = note: expected enum `std::option::Option>>` + found struct `std::string::String` + +error[E0308]: mismatched types + --> src/bind.rs:756:54 + | +756 | assert_eq!(result.doc.unwrap().combinedName, "".to_string()); + | ^^^^^^^^^^^^^^ expected `Option>>`, found `String` + | + = note: expected enum `std::option::Option>>` + found struct `std::string::String` + +error[E0308]: mismatched types + --> src/util.rs:117:9 + | +117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option`, found `Result<_, ErrorSet>` + | + ::: src/bind.rs:797:26 + | +797 | let description: Option = resolve!(left.doc.unwrap(), combinedDescription); + | -------------- ------------------------------------------------ in this macro invocation + | | + | expected due to this + | + = note: expected enum `std::option::Option` + found enum `std::result::Result<_, ErrorSet>` + = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) +help: consider using `Result::expect` to unwrap the `std::result::Result<_, ErrorSet>` value, panicking if the value is a `Result::Err` + --> src/bind.rs:797:91 + | +797 | let description: Option = resolve!(left.doc.unwrap(), combinedDescription).expect("REASON"); + | +++++++++++++++++ + +error[E0308]: mismatched types + --> src/util.rs:117:9 + | +117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option`, found `Result<_, ErrorSet>` + | + ::: src/bind.rs:799:19 + | +799 | let name: Option = resolve!(left.doc.unwrap(), combinedName); + | -------------- ----------------------------------------- in this macro invocation + | | + | expected due to this + | + = note: expected enum `std::option::Option` + found enum `std::result::Result<_, ErrorSet>` + = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) +help: consider using `Result::expect` to unwrap the `std::result::Result<_, ErrorSet>` value, panicking if the value is a `Result::Err` + --> src/bind.rs:799:77 + | +799 | let name: Option = resolve!(left.doc.unwrap(), combinedName).expect("REASON"); + | +++++++++++++++++ + +error[E0283]: type annotations needed + --> src/bind.rs:905:17 + | +905 | String::from(resolve!(item.doc.unwrap(), name).unwrap()), + | ^^^^^^ cannot infer type for type parameter `T` declared on the trait `From` + | +note: multiple `impl`s satisfying `std::string::String: From<_>` found + --> src/expression/value.rs:509:1 + | +509 | impl From> for String { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + ::: src/bind/validation.rs:178:1 + | +178 | impl From for String { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +... +260 | impl From for String { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + = note: and more `impl`s found in the following crates: `alloc`, `js_sys`, `rhai`, `smartstring`: + - impl From> for std::string::String; + - impl From for std::string::String; + - impl From for std::string::String; + - impl From for std::string::String; + - impl From for std::string::String; + - impl From for std::string::String; + +error[E0283]: type annotations needed + --> src/util.rs:117:9 + | +117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type + | + ::: src/bind.rs:905:30 + | +905 | String::from(resolve!(item.doc.unwrap(), name).unwrap()), + | --------------------------------- in this macro invocation + | +note: multiple `impl`s satisfying `std::option::Option>>: util::Resolving<_>` found + --> src/util.rs:155:1 + | +155 | / impl Resolving for Option +156 | | where +157 | | T: Resolving, +158 | | U: Default + LeafValue, + | |___________________________^ +... +168 | / impl Resolving> for Option +169 | | where +170 | | T: Resolving, + | |____________________^ + = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0283]: type annotations needed + --> src/util.rs:117:9 + | +117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type + | + ::: src/bind.rs:909:17 + | +909 | resolve!(item, args).unwrap(), + | -------------------- in this macro invocation + | +note: multiple `impl`s satisfying `std::option::Option>: util::Resolving<_>` found + --> src/util.rs:155:1 + | +155 | / impl Resolving for Option +156 | | where +157 | | T: Resolving, +158 | | U: Default + LeafValue, + | |___________________________^ +... +168 | / impl Resolving> for Option +169 | | where +170 | | T: Resolving, + | |____________________^ + = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) + +error[E0599]: no method named `unwrap` found for struct `bind::BindingInput` in the current scope + --> src/bind.rs:938:50 + | +65 | pub struct BindingInput { + | ----------------------- method `unwrap` not found for this struct +... +938 | let name: String = resolve!(items[i].unwrap(), name).unwrap(); + | ^^^^^^ method not found in `BindingInput` + | +help: some of the expressions' fields have a method of the same name + | +938 | let name: String = resolve!(items[i].args.unwrap(), name).unwrap(); + | +++++ +938 | let name: String = resolve!(items[i].default.unwrap(), name).unwrap(); + | ++++++++ +938 | let name: String = resolve!(items[i].doc.unwrap(), name).unwrap(); + | ++++ +938 | let name: String = resolve!(items[i].finalKey.unwrap(), name).unwrap(); + | +++++++++ + and 5 other candidates + +error[E0425]: cannot find function `parse_bytes` in this scope + --> src/file.rs:234:22 + | +234 | let result = parse_bytes(data); + | ^^^^^^^^^^^ not found in this scope + +error[E0609]: no field `name` on type `bind::Binding` + --> src/file.rs:269:35 + | +269 | assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + | ^^^^ unknown field + | +help: one of the expressions' fields has a field of the same name + | +269 | assert_eq!(result.bind[0].doc.name.as_ref().unwrap(), "the whole shebang"); + | ++++ + +error[E0609]: no field `name` on type `bind::Binding` + --> src/file.rs:310:35 + | +310 | assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + | ^^^^ unknown field + | +help: one of the expressions' fields has a field of the same name + | +310 | assert_eq!(result.bind[0].doc.name.as_ref().unwrap(), "the whole shebang"); + | ++++ + +error[E0609]: no field `name` on type `bind::Binding` + --> src/file.rs:343:32 + | +343 | result.bind[i].name.as_ref().unwrap().clone(), + | ^^^^ unknown field + | +help: one of the expressions' fields has a field of the same name + | +343 | result.bind[i].doc.name.as_ref().unwrap().clone(), + | ++++ + +error[E0308]: mismatched types + --> src/file.rs:368:49 + | +368 | let report = result.unwrap_err().report(data); + | ------ ^^^^ expected `&[u8]`, found `&str` + | | + | arguments to this method are incorrect + | + = note: expected reference `&[u8]` + found reference `&str` +note: method defined here + --> src/error.rs:370:12 + | +370 | pub fn report(&self, content: &[u8]) -> Vec { + | ^^^^^^ -------------- + +error[E0609]: no field `items` on type `ErrorReport` + --> src/file.rs:370:23 + | +370 | report[0].items[0].message, + | ^^^^^ unknown field + | + = note: available fields are: `message`, `range` + +error[E0609]: no field `items` on type `ErrorReport` + --> src/file.rs:373:30 + | +373 | assert_eq!(report[0].items[1].range.as_ref().unwrap().start.line, 1); + | ^^^^^ unknown field + | + = note: available fields are: `message`, `range` + +error[E0609]: no field `items` on type `ErrorReport` + --> src/file.rs:374:30 + | +374 | assert_eq!(report[0].items[1].range.as_ref().unwrap().end.line, 1); + | ^^^^^ unknown field + | + = note: available fields are: `message`, `range` + +warning: unused variable: `e` + --> src/expression.rs:178:17 + | +178 | Err(e) => Err(err!("{x} is not a valid JSON value"))?, + | ^ help: if this is intentional, prefix it with an underscore: `_e` + | + = note: `#[warn(unused_variables)]` on by default + +warning: unused variable: `e` + --> src/bind/command.rs:198:17 + | +198 | Err(e) => Err(err("object failed to serialize: {e}"))?, + | ^ help: if this is intentional, prefix it with an underscore: `_e` + +warning: unused variable: `x` + --> src/bind/validation.rs:158:49 + | +158 | KeyBinding(TypedValue::Constant(ref x)) => self, + | ^ help: if this is intentional, prefix it with an underscore: `_x` + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:676:35 + | +673 | let name: String = resolve!(result.doc.unwrap(), name).unwrap(); + | ---------- -------- `result.doc` moved due to this method call + | | + | help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +... +676 | let description: String = result + | ___________________________________^ +677 | | .doc + | |________________^ value used here after move + | +note: `std::option::Option::::unwrap` takes ownership of the receiver `self`, which moves `result.doc` + --> /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/option.rs:1000:25 + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +673 | let name: String = resolve!(result.doc.clone().unwrap(), name).unwrap(); + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:684:32 + | +676 | let description: String = result + | ___________________________________- +677 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +678 | .unwrap() + | -------- `result.doc` moved due to this method call +... +684 | let hideInDocs: bool = result + | ________________________________^ +685 | | .doc + | |________________^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +677 | .doc.clone() + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:692:35 + | +684 | let hideInDocs: bool = result + | ________________________________- +685 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +686 | .unwrap() + | -------- `result.doc` moved due to this method call +... +692 | let hideInPalette: bool = result + | ___________________________________^ +693 | | .doc + | |________________^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +685 | .doc.clone() + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:700:36 + | +692 | let hideInPalette: bool = result + | ___________________________________- +693 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +694 | .unwrap() + | -------- `result.doc` moved due to this method call +... +700 | let combinedName: String = result + | ____________________________________^ +701 | | .doc + | |________________^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +693 | .doc.clone() + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:708:35 + | +700 | let combinedName: String = result + | ____________________________________- +701 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +702 | .unwrap() + | -------- `result.doc` moved due to this method call +... +708 | let combinedKey: String = result + | ___________________________________^ +709 | | .doc + | |________________^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +701 | .doc.clone() + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:716:43 + | +708 | let combinedKey: String = result + | ___________________________________- +709 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +710 | .unwrap() + | -------- `result.doc` moved due to this method call +... +716 | let combinedDescription: String = result + | ___________________________________________^ +717 | | .doc + | |________________^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +709 | .doc.clone() + | ++++++++ + +error[E0382]: use of moved value: `result.doc` + --> src/bind.rs:724:37 + | +716 | let combinedDescription: String = result + | ___________________________________________- +717 | | .doc + | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents +718 | .unwrap() + | -------- `result.doc` moved due to this method call +... +724 | let kind: String = resolve!(result.doc.unwrap(), kind).unwrap(); + | ^^^^^^^^^^ value used here after move + | + = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait +help: you can `clone` the value and consume it, but this might not be your desired behavior + | +717 | .doc.clone() + | ++++++++ + +Some errors have detailed explanations: E0283, E0308, E0382, E0425, E0599, E0609. +For more information about an error, try `rustc --explain E0283`. +warning: `parsing` (lib test) generated 6 warnings +error: could not compile `parsing` (lib test) due to 23 previous errors; 6 warnings emitted +[test-rust] ERROR task failed diff --git a/mise.toml b/mise.toml index f0c775cf..ce486ae8 100644 --- a/mise.toml +++ b/mise.toml @@ -7,7 +7,7 @@ node = "20" "npm:pnpm" = "10.13.1" "ubi:haberdashpi/simple-src-docs" = "0.6.0" watchexec = "2.3.2" -rust = { version = "1.88", targets = "wasm32-unknown-unknown", component = "lvm-tools" } +rust = { version = "1.89", targets = "wasm32-unknown-unknown", component = "lvm-tools" } "cargo:wasm-pack" = "0.13.1" "cargo:cargo-binutils" = "0.3.6" "cargo:rustfilt" = "latest" diff --git a/notes.md b/notes.md index 1000307b..68ae85b8 100644 --- a/notes.md +++ b/notes.md @@ -151,10 +151,12 @@ Integration test debugging: - [X] refactor plural to use `into` / `from` Vec - [X] update documentation rendering pipeline - [ ] error reporting is still a little finicky - - [ ] could probably make what is part of the same error more explicit - - [ ] reduce types of errors and tie error message string more explicitly + - [ ] properly inject Rhai expression range into errors + - [X] could probably make what is part of the same error more explicit + - [X] reduce types of errors and tie error message string more explicitly to name of enum variant - [ ] fix and test command queues implementation (avoid so much copying) + - [ ] support spans for expressions - [ ] re-run tests - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` diff --git a/src/rust/parsing/errors.txt b/src/rust/parsing/errors.txt index 50382150..d91d5e2c 100644 --- a/src/rust/parsing/errors.txt +++ b/src/rust/parsing/errors.txt @@ -1,5 +1,420 @@ +[test-rust] $ def main [...args] { + Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) +warning: unused import: `RawError` + --> src/util.rs:9:41 + | +9 | use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, flatten_errors}; + | ^^^^^^^^ + | + = note: `#[warn(unused_imports)]` on by default -running 0 tests +warning: unused import: `crate::err` + --> src/bind/validation.rs:8:5 + | +8 | use crate::err; + | ^^^^^^^^^^ -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s +warning: unused import: `RawError` + --> src/bind/validation.rs:9:30 + | +9 | use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; + | ^^^^^^^^ +warning: unused variable: `e` + --> src/expression.rs:178:17 + | +178 | Err(e) => Err(err!("{x} is not a valid JSON value"))?, + | ^ help: if this is intentional, prefix it with an underscore: `_e` + | + = note: `#[warn(unused_variables)]` on by default + +warning: unused variable: `e` + --> src/bind/command.rs:198:17 + | +198 | Err(e) => Err(err("object failed to serialize: {e}"))?, + | ^ help: if this is intentional, prefix it with an underscore: `_e` + +warning: unused variable: `x` + --> src/bind/validation.rs:158:49 + | +158 | KeyBinding(TypedValue::Constant(ref x)) => self, + | ^ help: if this is intentional, prefix it with an underscore: `_x` + +warning: variable does not need to be mutable + --> src/bind.rs:869:13 + | +869 | let mut result = toml::from_str::(data).unwrap(); + | ----^^^^^^ + | | + | help: remove this `mut` + | + = note: `#[warn(unused_mut)]` on by default + +warning: variable does not need to be mutable + --> src/bind.rs:904:13 + | +904 | let mut result = toml::from_str::(data).unwrap(); + | ----^^^^^^ + | | + | help: remove this `mut` + +warning: methods `with_expression_range` and `with_pos` are never used + --> src/error.rs:107:8 + | +90 | pub trait ErrorContext + | ------------ methods in this trait +... +107 | fn with_expression_range( + | ^^^^^^^^^^^^^^^^^^^^^ +... +117 | fn with_pos(self, context: rhai::Position) -> std::result::Result { + | ^^^^^^^^ + | + = note: `#[warn(dead_code)]` on by default + +warning: unused return value of `rhai::api::options::::allow_statement_expression` that must be used + --> src/expression.rs:144:9 + | +144 | engine.set_allow_looping(false).allow_statement_expression(); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: `#[warn(unused_must_use)]` on by default +help: use `let _ = ...` to ignore the resulting value + | +144 | let _ = engine.set_allow_looping(false).allow_statement_expression(); + | +++++++ + +warning: unused `std::result::Result` that must be used + --> src/bind/validation.rs:170:21 + | +170 | toml.serialize(serializer); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this `Result` may be an `Err` variant, which should be handled +help: use `let _ = ...` to ignore the resulting value + | +170 | let _ = toml.serialize(serializer); + | +++++++ + +warning: unused `std::result::Result` that must be used + --> src/bind.rs:937:9 + | +937 | scope.parse_asts(&input); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this `Result` may be an `Err` variant, which should be handled +help: use `let _ = ...` to ignore the resulting value + | +937 | let _ = scope.parse_asts(&input); + | +++++++ + +warning: unused `std::result::Result` that must be used + --> src/file.rs:138:9 + | +138 | define.add_to_scope(&mut scope); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: this `Result` may be an `Err` variant, which should be handled +help: use `let _ = ...` to ignore the resulting value + | +138 | let _ = define.add_to_scope(&mut scope); + | +++++++ + +warning: `parsing` (lib test) generated 13 warnings (run `cargo fix --lib -p parsing --tests` to apply 5 suggestions) + Finished `test` profile [unoptimized + debuginfo] target(s) in 2.90s + Running unittests src/lib.rs (target/debug/deps/parsing-8ee028e04a7e2ca2) + +thread 'bind::tests::expands_foreach' panicked at src/bind.rs:881:50: +called `Option::unwrap()` on a `None` value +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::panic + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 + 3: core::option::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 + 4: core::option::Option::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 + 5: parsing::bind::tests::expands_foreach + at ./src/bind.rs:881:50 + 6: parsing::bind::tests::expands_foreach::{{closure}} + at ./src/bind.rs:860:25 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 8: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::expand_foreach_keys' panicked at src/bind.rs:913:62: +called `Option::unwrap()` on a `None` value +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::panic + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 + 3: core::option::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 + 4: core::option::Option::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 + 5: parsing::bind::tests::expand_foreach_keys + at ./src/bind.rs:913:62 + 6: parsing::bind::tests::expand_foreach_keys::{{closure}} + at ./src/bind.rs:894:29 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 8: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::simple_command_merging' panicked at src/bind.rs:773:28: +called `Option::unwrap()` on a `None` value +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::panic + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 + 3: core::option::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 + 4: core::option::Option::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 + 5: parsing::bind::tests::simple_command_merging + at ./src/bind.rs:773:28 + 6: parsing::bind::tests::simple_command_merging::{{closure}} + at ./src/bind.rs:736:32 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 8: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::complete_parsing' panicked at src/bind.rs:629:59: +called `Result::unwrap()` on an `Err` value: Error { message: "invalid type: string \"normal\", expected a sequence", input: Some("\n command = \"do\"\n args = { a = \"2\", b = 3 }\n key = \"a\"\n when = \"joe > 1\"\n mode = \"normal\"\n priority = 1\n default = \"{{bind.foo_bar}}\"\n foreach.index = [1,2,3]\n prefixes = \"c\"\n finalKey = true\n repeat = \"{{2+c}}\"\n name = \"foo\"\n description = \"foo bar bin\"\n hideInPalette = false\n hideInDocs = false\n combinedName = \"Up/down\"\n combinedKey = \"A/B\"\n combinedDescription = \"bla bla bla\"\n kind = \"biz\"\n "), keys: ["mode"], span: Some(116..124) } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::complete_parsing + at ./src/bind.rs:629:59 + 5: parsing::bind::tests::complete_parsing::{{closure}} + at ./src/bind.rs:606:26 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::default_parsing' panicked at src/bind.rs:726:30: +called `Option::unwrap()` on a `None` value +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::panic + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 + 3: core::option::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 + 4: core::option::Option::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 + 5: parsing::bind::tests::default_parsing + at ./src/bind.rs:726:30 + 6: parsing::bind::tests::default_parsing::{{closure}} + at ./src/bind.rs:702:25 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 8: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::merge_nested_arguments' panicked at src/bind.rs:805:9: +assertion `left == right` failed + left: Some(Spanned { span: 98..102, value: Table({"foo": Table({"a": Integer(2), "b": Integer(3), "c": Table({"x": Integer(1)})})}) }) + right: Some(Spanned { span: 345..349, value: Table({"foo": Table({"a": Integer(2), "b": Integer(3), "c": Table({"x": Integer(1), "y": Integer(2)}), "d": Integer(12)})}) }) +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::assert_failed_inner + 3: core::panicking::assert_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 + 4: parsing::bind::tests::merge_nested_arguments + at ./src/bind.rs:805:9 + 5: parsing::bind::tests::merge_nested_arguments::{{closure}} + at ./src/bind.rs:781:32 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::merge_nested_array_arguments' panicked at src/bind.rs:856:9: +assertion `left == right` failed + left: Some(Spanned { span: 107..111, value: Table({"commands": Array([Table({"args": Table({"b": String("bar")}), "command": String("step1")}), Table({"args": Table({"x": String("biz")}), "command": String("step2")})])}) }) + right: Some(Spanned { span: 696..700, value: Table({"commands": Array([Table({"args": Table({"a": String("foo"), "b": String("bar")}), "command": String("step1")}), Table({"args": Table({"x": String("biz"), "y": String("fiz")}), "command": String("step2")})])}) }) +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::assert_failed_inner + 3: core::panicking::assert_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 + 4: parsing::bind::tests::merge_nested_array_arguments + at ./src/bind.rs:856:9 + 5: parsing::bind::tests::merge_nested_array_arguments::{{closure}} + at ./src/bind.rs:809:38 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::parse_example' panicked at src/file.rs:234:58: +called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: TomlParsing(Error { message: "invalid type: string \"normal\", expected a sequence", input: Some("\n [[define.var]]\n foo = \"bar\"\n\n [[bind]]\n key = \"l\"\n mode = \"normal\"\n command = \"cursorRight\"\n\n [[bind]]\n key = \"h\"\n model = \"normal\"\n command = \"cursorLeft\"\n "), keys: ["bind", "mode"], span: Some(95..103) }), contexts: [] }] } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::file::tests::parse_example + at ./src/file.rs:234:58 + 5: parsing::file::tests::parse_example::{{closure}} + at ./src/file.rs:218:23 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::foreach_error' panicked at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:291:32: +attempt to add with overflow +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::panic_const::panic_const_add_overflow + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:175:17 + 3: string_offsets::StringOffsets::utf8_to_char + at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:291:32 + 4: string_offsets::StringOffsets::utf8_to_char_pos + at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:264:29 + 5: parsing::error::range_to_pos + at ./src/error.rs:277:23 + 6: parsing::error::Error::report + at ./src/error.rs:327:41 + 7: parsing::error::ErrorSet::report::{{closure}} + at ./src/error.rs:371:45 + 8: core::iter::adapters::map::map_fold::{{closure}} + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/adapters/map.rs:88:28 + 9: as core::iter::traits::iterator::Iterator>::fold + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/slice/iter/macros.rs:255:27 + 10: as core::iter::traits::iterator::Iterator>::fold + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/adapters/map.rs:128:19 + 11: core::iter::traits::iterator::Iterator::for_each + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/traits/iterator.rs:827:14 + 12: alloc::vec::Vec::extend_trusted + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/mod.rs:3611:26 + 13: as alloc::vec::spec_extend::SpecExtend>::spec_extend + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_extend.rs:29:14 + 14: as alloc::vec::spec_from_iter_nested::SpecFromIterNested>::from_iter + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_from_iter_nested.rs:62:16 + 15: as alloc::vec::spec_from_iter::SpecFromIter>::from_iter + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_from_iter.rs:34:9 + 16: as core::iter::traits::collect::FromIterator>::from_iter + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/mod.rs:3470:9 + 17: core::iter::traits::iterator::Iterator::collect + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/traits/iterator.rs:2027:9 + 18: parsing::error::ErrorSet::report + at ./src/error.rs:371:62 + 19: parsing::file::tests::foreach_error + at ./src/file.rs:364:42 + 20: parsing::file::tests::foreach_error::{{closure}} + at ./src/file.rs:353:23 + 21: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 22: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::resolve_nested_command' panicked at src/file.rs:307:82: +called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: ExpressionParsing(ParseError(Reserved("var"), 1:1)), contexts: [Range(191..195), Range(374..382)] }] } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::file::tests::resolve_nested_command + at ./src/file.rs:307:82 + 5: parsing::file::tests::resolve_nested_command::{{closure}} + at ./src/file.rs:282:32 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::resolve_bind_and_command' panicked at src/file.rs:266:82: +called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: ExpressionParsing(ParseError(Reserved("var"), 1:1)), contexts: [Range(324..328), Range(384..392)] }] } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::file::tests::resolve_bind_and_command + at ./src/file.rs:266:82 + 5: parsing::file::tests::resolve_bind_and_command::{{closure}} + at ./src/file.rs:243:34 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::expand_foreach' panicked at src/file.rs:341:13: +assertion `left == right` failed + left: "" + right: "update 0" +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::panicking::assert_failed_inner + 3: core::panicking::assert_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 + 4: parsing::file::tests::expand_foreach + at ./src/file.rs:341:13 + 5: parsing::file::tests::expand_foreach::{{closure}} + at ./src/file.rs:323:24 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. +error: test failed, to rerun pass `--lib` +[test-rust] ERROR task failed diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 53aecbda..17066f39 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -15,26 +15,27 @@ pub mod validation; use crate::bind::command::{Command, regularize_commands}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{Result, ResultVec, reserved, unexpected}; +use crate::error::{Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, TypedValue, Value}; +use crate::resolve; use crate::util::{Merging, Plural, Required, Resolving}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; -fn default_mode() -> Spanned>> { - return Spanned::new(UNKNOWN_RANGE, Plural::default()); +fn default_mode() -> Spanned>> { + return Spanned::new( + UNKNOWN_RANGE, + TypedValue::Constant(Plural(vec!["default".to_string()])), + ); } fn span_required_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Required::DefaultValue); } -fn span_plural_default() -> Spanned> -where - T: Clone, -{ - return Spanned::new(UNKNOWN_RANGE, Plural::default()); +fn span_plural_default() -> Spanned>> { + return Spanned::new(UNKNOWN_RANGE, TypedValue::default()); } // @@ -106,7 +107,7 @@ pub struct BindingInput { /// [`all_modes`](/expressions/functions#all_modes) and /// [`all_modes_but`](/expressions/functions#all_modes_but) #[serde(default = "default_mode")] - pub mode: Spanned>>, + pub mode: Spanned>>, /// @forBindingField bind /// /// - `priority`: The ordering of the keybinding relative to others; determines which @@ -139,7 +140,7 @@ pub struct BindingInput { /// sequence that has been pressed: this is how `esc` is defined to work /// in Larkin. #[serde(default = "span_plural_default")] - pub prefixes: Spanned>>, + pub prefixes: Spanned>>, /// @forBindingField bind /// @@ -203,7 +204,7 @@ pub struct BindingInput { /// - `master-key.prefix`: The currently active [keybinding prefix](/commands/prefix) /// - `master-key.record`: a boolean flag used to indicate when keys are marked for /// recording -/// - `master-key.var.[name]`: the current value of a +/// - `master-key.val.[name]`: the current value of a /// [defined variable](/bindings/define#variable-definitions). /// - `master-key.keybindingPaletteBindingMode`: true when the suggestion palette accepts /// keybinding key presses, false it accepts a string to search the descriptions of said @@ -304,7 +305,7 @@ impl Expanding for BindingInput { }), mode: self.mode.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Plural::default()) + Spanned::new(UNKNOWN_RANGE, TypedValue::default()) }), priority: self.priority.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -316,7 +317,7 @@ impl Expanding for BindingInput { }), prefixes: self.prefixes.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Plural::default()) + Spanned::new(UNKNOWN_RANGE, TypedValue::default()) }), finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -492,6 +493,15 @@ impl Expanding for BindingDocInput { } } +impl Resolving for Option { + fn resolve(self, _name: &'static str) -> ResultVec { + match self { + Some(doc) => Ok(BindingDoc::new(doc)?), + None => Ok(BindingDoc::default()), + } + } +} + // // ================ `[[bind]]` object ================ // @@ -507,26 +517,23 @@ pub struct Binding { pub priority: f64, pub prefixes: Vec, pub finalKey: bool, - pub(crate) repeat: Option>, - pub doc: Option, + pub(crate) repeat: TypedValue, + pub doc: BindingDoc, } #[wasm_bindgen] impl Binding { pub fn repeat(&mut self, scope: &mut Scope) -> ResultVec { - return match scope.expand(&self.repeat)? { - None => Ok(0), - Some(val) => Ok(val.into()), - }; + return scope.expand(&self.repeat)?.resolve("`repeat`"); } pub(crate) fn new(input: BindingInput) -> ResultVec { if let Some(_) = input.id { - return reserved("id")?; + return Err(err("`id` field is reserved"))?; } if let Some(_) = input.foreach { - return unexpected("`foreach` with unresolved variables")?; + return Err(err("`foreach` included unresolved variables"))?; } let commands = regularize_commands(&input)?; @@ -534,17 +541,14 @@ impl Binding { return Ok(Binding { commands: commands, - key: input.key.resolve("`key` field")?, - when: input.when.resolve("`when` field")?, - mode: input.mode.resolve("`mode` field")?, - priority: input.priority.resolve("`priority` field")?.unwrap_or(0.0), - prefixes: input.prefixes.resolve("`prefixes` fields")?, - finalKey: input.finalKey.resolve("`finalKey` field")?.unwrap_or(true), - repeat: input.repeat.resolve("`repeat` field")?, - doc: match input.doc { - Some(doc) => Some(BindingDoc::new(doc)?), - None => None, - }, + key: resolve!(input, key)?, + when: resolve!(input, when)?, + mode: resolve!(input, mode)?, + priority: resolve!(input, priority)?, + prefixes: resolve!(input, prefixes)?, + finalKey: resolve!(input, finalKey)?, + repeat: resolve!(input, repeat)?, + doc: resolve!(input, doc)?, }); } } @@ -553,40 +557,32 @@ impl Binding { // ---------------- `bind.doc` object ---------------- // -#[derive(Clone, Debug, Serialize)] +#[derive(Clone, Debug, Serialize, Default)] #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct BindingDoc { - pub name: Option, - pub description: Option, + pub name: String, + pub description: String, pub hideInPalette: bool, pub hideInDocs: bool, - pub combinedName: Option, - pub combinedKey: Option, - pub combinedDescription: Option, - pub kind: Option, + pub combinedName: String, + pub combinedKey: String, + pub combinedDescription: String, + pub kind: String, } #[wasm_bindgen] impl BindingDoc { pub(crate) fn new(input: BindingDocInput) -> ResultVec { return Ok(BindingDoc { - name: input.name.resolve("`name` field")?, - description: input.description.resolve("`description` field")?, - hideInPalette: input - .hideInPalette - .resolve("`hideInPalette`")? - .unwrap_or(false), - hideInDocs: input - .hideInDocs - .resolve("`hideInPalette`")? - .unwrap_or(false), - combinedName: input.combinedName.resolve("`combinedName` field")?, - combinedKey: input.combinedKey.resolve("`combinedKey` field")?, - combinedDescription: input - .combinedDescription - .resolve("`combinedDescription` field")?, - kind: input.kind.resolve("`kind` field")?, + name: resolve!(input, name)?, + description: resolve!(input, description)?, + hideInPalette: resolve!(input, hideInPalette)?, + hideInDocs: resolve!(input, hideInDocs)?, + combinedName: resolve!(input, combinedName)?, + combinedKey: resolve!(input, combinedKey)?, + combinedDescription: resolve!(input, combinedDescription)?, + kind: resolve!(input, kind)?, }); } } @@ -617,14 +613,14 @@ mod tests { prefixes = "c" finalKey = true repeat = "{{2+c}}" - name = "foo" - description = "foo bar bin" - hideInPalette = false - hideInDocs = false - combinedName = "Up/down" - combinedKey = "A/B" - combinedDescription = "bla bla bla" - kind = "biz" + doc.name = "foo" + doc.description = "foo bar bin" + doc.hideInPalette = false + doc.hideInDocs = false + doc.combinedName = "Up/down" + doc.combinedKey = "A/B" + doc.combinedDescription = "bla bla bla" + doc.kind = "biz" "#; let result = toml::from_str::(data).unwrap(); @@ -646,11 +642,7 @@ mod tests { assert_eq!(key, "a".to_string()); let when: String = result.when.unwrap().into_inner().into(); assert_eq!(when, "joe > 1".to_string()); - let mode: Vec = result - .mode - .into_inner() - .map(|m| m.clone().into()) - .to_array(); + let mode: Vec = resolve!(result, mode).unwrap(); assert_eq!(mode, ["normal"]); let priority: f64 = result.priority.unwrap().into_inner().into(); @@ -662,45 +654,44 @@ mod tests { let foreach = result.foreach.unwrap(); let values = foreach.get("index").unwrap(); let numbers: Vec = values.iter().map(|it| it.clone().into_inner()).collect(); - assert_eq!(numbers, [ - Value::Integer(1), - Value::Integer(2), - Value::Integer(3) - ]); + assert_eq!( + numbers, + [Value::Integer(1), Value::Integer(2), Value::Integer(3)] + ); assert_eq!(when, "joe > 1".to_string()); - let prefixes: Vec = result - .prefixes - .into_inner() - .map(|m| m.clone().into()) - .to_array(); + let prefixes: Vec = resolve!(result, prefixes).unwrap(); assert_eq!(prefixes, ["c"]); - let finalKey: bool = result.finalKey.unwrap().into_inner().into(); + let finalKey: bool = resolve!(result, finalKey).unwrap(); assert_eq!(finalKey, true); - let name: String = result.name.unwrap().into_inner().into(); + let doc = result.doc.unwrap(); + let name: String = resolve!(doc, name).unwrap(); assert_eq!(name, "foo"); - let description: String = result.description.unwrap().into_inner().into(); + let description: String = doc.description.resolve("`description`").unwrap(); assert_eq!(description, "foo bar bin"); - let hideInDocs: bool = result.hideInDocs.unwrap().into_inner().into(); + let hideInDocs: bool = doc.hideInDocs.resolve("`hideInDocs`").unwrap(); assert_eq!(hideInDocs, false); - let hideInPalette: bool = result.hideInPalette.unwrap().into_inner().into(); + let hideInPalette: bool = doc.hideInPalette.resolve("`hideInPalette`").unwrap(); assert_eq!(hideInPalette, false); - let combinedName: String = result.combinedName.unwrap().into_inner().into(); + let combinedName: String = doc.combinedName.resolve("`combinedName`").unwrap(); assert_eq!(combinedName, "Up/down"); - let combinedKey: String = result.combinedKey.unwrap().into_inner().into(); + let combinedKey: String = doc.combinedKey.resolve("`combinedKey`").unwrap(); assert_eq!(combinedKey, "A/B"); - let combinedDescription: String = result.combinedDescription.unwrap().into_inner().into(); + let combinedDescription: String = doc + .combinedDescription + .resolve("`combinedDescription`") + .unwrap(); assert_eq!(combinedDescription, "bla bla bla"); - let kind: String = result.kind.unwrap().into_inner().into(); + let kind: String = resolve!(doc, kind).unwrap(); assert_eq!(kind, "biz"); } @@ -729,23 +720,23 @@ mod tests { )])) ); - let modes: Vec = result.mode.resolve("`mode` field").unwrap(); - assert_eq!(modes.first(), "default".to_string()); - assert_eq!(result.combinedDescription, None); - assert_eq!(result.combinedName, None); + let modes: Vec = resolve!(result, mode).unwrap(); + assert_eq!(modes.first().unwrap(), &"default".to_string()); + let when: Option = resolve!(result, when).unwrap(); + assert_eq!(when, None); } #[test] fn simple_command_merging() { let data = r#" [[bind]] - name = "default" + doc.name = "default" command = "cursorMove" prefixes = ["a"] [[bind]] key = "l" - name = "←" + doc.name = "←" args.to = "left" prefixes = ["b", "c"] "#; @@ -755,7 +746,7 @@ mod tests { let left = result.get("bind").unwrap()[1].clone(); let left = default.merge(left); - let key: String = left.key.into_inner().unwrap().into(); + let key: String = resolve!(left, key).unwrap(); assert_eq!(key, "l".to_string()); assert_eq!( String::from(left.command.into_inner().unwrap()), @@ -770,33 +761,32 @@ mod tests { )])) ); - let prefixes: Vec = left - .prefixes - .into_inner() - .map(|m| m.clone().into()) - .to_array(); + let prefixes: Vec = resolve!(left, prefixes).unwrap(); assert_eq!(prefixes, ["b".to_string(), "c".to_string()]); - assert_eq!(left.combinedDescription, None); - assert_eq!(left.combinedName, None); + let doc = left.doc.unwrap(); + let description: Option = resolve!(doc, combinedDescription).unwrap(); + assert_eq!(description, None); + let name: Option = resolve!(doc, combinedName).unwrap(); + assert_eq!(name, None); } #[test] fn merge_nested_arguments() { let data = r#" [[bind]] - name = "default" + doc.name = "default" command = "cursorMove" args.foo = { a = 2, b = 3, c = { x = 1 } } [[bind]] key = "r" - name = "→" + doc.name = "→" args.foo = { d = 12, c = { y = 2 } } [[bind]] key = "x" - name = "expected" + doc.name = "expected" args.foo = { a = 2, b = 3, c = { x = 1, y = 2 }, d = 12 } "#; @@ -865,7 +855,7 @@ mod tests { let data = r#" foreach.a = [1, 2] foreach.b = ["x", "y"] - name = "test {{a}}-{{b}}" + doc.name = "test {{a}}-{{b}}" command = "run-{{a}}" args.value = "with-{{b}}" "#; @@ -879,32 +869,26 @@ mod tests { for i in 0..4 { let item = items[i].clone(); - assert_eq!( - String::from(item.command.into_inner().unwrap()), - expected_command[i] - ); + let command: String = resolve!(item, command).unwrap(); + assert_eq!(command, expected_command[i]); - assert_eq!( - String::from(item.name.unwrap().into_inner()), - expected_name[i] - ); - assert_eq!( - item.args.unwrap().into_inner(), - Value::Table(BTreeMap::from([( - "value".to_string(), - Value::String(expected_value[i].into()) - )])) + let name: String = resolve!(item.doc.unwrap(), name).unwrap(); + assert_eq!(name, expected_name[i]); + let args: Option = resolve!(item, args).unwrap(); + let mut expected_args = toml::Table::new(); + expected_args.insert( + "value".to_string(), + toml::Value::String(expected_value[i].into()), ); + assert_eq!(args.unwrap(), toml::Value::Table(expected_args)); } } #[test] fn expand_foreach_keys() { - // TODO: error out if the regex inside of `{{}}` is not valid (right now it just - // fails silently) let data = r#" foreach.key = ["{{keys(`[0-9]`)}}"] - name = "update {{key}}" + doc.name = "update {{key}}" command = "foo" args.value = "{{key}}" "#; @@ -918,16 +902,15 @@ mod tests { assert_eq!(items.len(), 10); for i in 0..9 { - let name: String = items[i].name.as_ref().unwrap().get_ref().clone().into(); + let name: String = resolve!(items[i].doc.clone().unwrap(), name).unwrap(); assert_eq!(name, expected_name[i]); - let value = items[i].args.as_ref().unwrap().get_ref().clone(); - assert_eq!( - value, - Value::Table(BTreeMap::from([( - "value".to_string(), - Value::String(expected_value[i].clone()) - )])) + let value: Option = resolve!(items[i].clone(), args).unwrap(); + let mut table = toml::Table::new(); + table.insert( + "value".to_string(), + toml::Value::String(expected_value[i].clone()), ); + assert_eq!(value.unwrap(), toml::Value::Table(table)); } } @@ -935,7 +918,7 @@ mod tests { fn expand_args() { let data = r#" key = "k" - name = "test" + doc.name = "test" command = "foo" args.value = '{{joe + "_biz"}}' args.number = '{{2+1}}' diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 3437eda7..298dcb68 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -1,13 +1,14 @@ -use std::collections::BTreeMap; use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; use toml::Spanned; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ bind::{BindingInput, UNKNOWN_RANGE}, - error::{RawError, ErrorContext, Error, Result, ResultVec, constrain, reserved}, + error::{ErrorContext, Result, ResultVec, err}, expression::Scope, expression::value::{Expanding, TypedValue, Value}, + resolve, util::{Required, Resolving}, }; @@ -102,7 +103,7 @@ impl From for Value { } pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec> { - let command: String = input.clone().command.resolve("`command` field")?; + let command: String = input.clone().command.resolve("`command`")?; if command != "runCommands" { let commands = vec![Command { command, @@ -116,27 +117,24 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec kv .get("commands") - .ok_or_else(|| { - RawError::Constraint("`runCommands` must have `args.commands` field".into()) - })? + .ok_or_else(|| err("`runCommands` must have `args.commands` field"))? .clone(), - _ => Err(RawError::Validation( - "Expected `args` to be an object with `commands` field".to_string(), - ))?, + _ => { + return Err(err("Expected `args` to be an object with `commands` field"))?; + } }; let command_vec = match commands { Value::Array(items) => items, - _ => Err(RawError::Validation( - "Expected `args.commands` of `runCommands` to \ - be a vector of commands to run." - .to_string(), - ))?, + _ => { + return Err(err("Expected `args.commands` of `runCommands` to \ + be a vector of commands to run."))?; + } }; let mut command_result = Vec::with_capacity(command_vec.len()); @@ -145,37 +143,32 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec (str.to_owned(), Value::Table(BTreeMap::new())), Value::Table(kv) => { - let result = kv.get("command").ok_or_else({ - || { - RawError::RequiredField( - "`args.commands.command` field for `runCommands`".into(), - ) - } + let result = kv.get("command").ok_or_else(|| { + err("expected `args.commands.command` field for `runCommands`") })?; let command_name = match result { Value::String(x) => x.to_owned(), _ => { - let err: Error = - RawError::Constraint("`command` to be a string".into()).into(); - Err(err).context_range(&args_pos)? + return Err(err("expected `command` to be a string")) + .with_range(&args_pos)?; } }; let result = kv.get("args").ok_or_else(|| { - RawError::RequiredField("`args.commands.arg` field for `runCommands`".into()) + err("expected `args.commands.arg` field for `runCommands`") })?; let args = match result { x @ Value::Table(_) => x, x @ Value::Array(_) => x, _ => { - return Err(RawError::Constraint("`args` to be a table or array".into()))?; + return Err(err("expected `args` to be a table or array"))?; } }; (command_name, args.to_owned()) } _ => { - return constrain( + return Err(err( "`commands` to be an array that includes objects and strings only", - )?; + ))?; } }; command_result.push(Command { command, args }) @@ -202,7 +195,7 @@ impl Command { pub fn args(&self, scope: &mut Scope) -> ResultVec { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return match self.toml_args(scope)?.serialize(&to_json) { - Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, + Err(e) => Err(err("object failed to serialize: {e}"))?, Ok(x) => Ok(x), }; } @@ -211,10 +204,10 @@ impl Command { impl Command { pub fn new(input: CommandInput) -> ResultVec { if let Some(_) = input.id { - return reserved("id")?; + return Err(err("`id` fields is reserved"))?; } return Ok(Command { - command: input.command.resolve("`command` field")?, + command: resolve!(input, command)?, args: match input.args { Some(x) => x.into_inner(), None => Value::Table(BTreeMap::new()), diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 4760edcc..02c0ee58 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -294,7 +294,7 @@ impl BindingInput { pub fn expand_foreach(self) -> ResultVec> { if self.has_foreach() { let foreach = expand_keys(self.foreach.clone().unwrap())?; - foreach.require_constant().context_str( + foreach.require_constant().with_message( "`foreach` values can only include expressions of the form {{keys(`regex`)}}", )?; diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 3e05e288..1a7051dc 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -1,7 +1,3 @@ -use crate::error::{ErrorSet, RawError, Result, ResultVec}; -use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; -use crate::util::{Merging, Resolving}; - #[allow(unused_imports)] use log::info; @@ -9,6 +5,11 @@ use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; +use crate::err; +use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; +use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; +use crate::util::{Merging, Resolving}; + // // ---------------- Keybinding Validation ---------------- // @@ -105,11 +106,11 @@ fn valid_key_binding_str(str: &str) -> Result<()> { if first { first = false; if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { - return Err(RawError::Validation(format!("key name {part}")))?; + return Err(err("`{part}` is an invalid key"))?; } } else { if !MODIFIER_REGEX.is_match(part) { - return Err(RawError::Validation(format!("modifier name {part}")))?; + return Err(err("`{part}` is an invalid modiier key"))?; } } } @@ -122,7 +123,7 @@ fn valid_key_binding_str(str: &str) -> Result<()> { pub struct KeyBinding(TypedValue); impl TryFrom for KeyBinding { - type RawError = ErrorSet; + type Error = ErrorSet; fn try_from(value: String) -> ResultVec { if EXPRESSION.is_match(&value) { return Ok(KeyBinding(TypedValue::Variable( @@ -136,7 +137,7 @@ impl TryFrom for KeyBinding { } impl Resolving for KeyBinding { - fn resolve(self, name: impl Into) -> ResultVec { + fn resolve(self, _name: &'static str) -> ResultVec { self.require_constant()?; Ok(self.into()) } @@ -162,7 +163,13 @@ impl Expanding for KeyBinding { valid_key_binding_str(&val)?; KeyBinding(TypedValue::Constant(val)) } - other @ _ => return Err(RawError::Unexpected("non-string value"))?, + other @ _ => { + let mut result = String::new(); + let toml: toml::Value = other.into(); + let serializer = toml::ser::ValueSerializer::new(&mut result); + toml.serialize(serializer); + return Err(err("expected a string, found `{result}`"))?; + } }, }) } @@ -211,7 +218,7 @@ lazy_static! { pub struct BindingReference(pub(crate) String); impl TryFrom for BindingReference { - type RawError = ErrorSet; + type Error = ErrorSet; fn try_from(value: String) -> ResultVec { let value: Value = toml::Value::String(value).try_into()?; match value { @@ -221,12 +228,12 @@ impl TryFrom for BindingReference { captures.get(1).expect("variable name").as_str().to_string(), )) } else { - Err(RawError::Validation( + Err(err( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), ))? } } - _ => Err(RawError::Validation( + _ => Err(err( "binding reference (must be of the form `{{bind.[identifier]}}`".into(), ))?, } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 20769dde..82aa1b42 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -12,7 +12,8 @@ use toml::Spanned; use crate::bind::BindingInput; use crate::bind::command::CommandInput; use crate::bind::validation::BindingReference; -use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, unexpected}; +use crate::err; +use crate::error::{Error, ErrorContext, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Value}; use crate::util::{Merging, Resolving}; @@ -24,7 +25,7 @@ use crate::util::{Merging, Resolving}; /// The `define` field can be used to define re-usable values. There are three types of /// values that can be defined. /// -/// 1. `[[define.var]]:` variable definitions: defines any number of key-value pairs that can +/// 1. `[[define.val]]:` variable definitions: defines any number of key-value pairs that can /// be referenced inside an [expression](/expressions/index) /// 2. `[[define.command]]`: command definitions: defines one or more commands that can be /// referenced when [running multiple commands](/bindings/bind#running-multiple-commands). @@ -38,7 +39,7 @@ pub struct DefineInput { /// ## Variable Definitions /// /// These can be any arbitrary TOML value. You can define multiple variables within - /// each `[[define.var]]` element this way. These are then available in any + /// each `[[define.val]]` element this way. These are then available in any /// [expressions](/expressions/index) /// evaluated at runtime and in [when clauses](/bindings/bind#available-when-contexts). /// @@ -85,7 +86,7 @@ pub struct DefineInput { /// args.after = "{{braces[captured].?after ?? captured}}" /// args.followCursor = true /// ``` - pub var: Option>>>, + pub val: Option>>>, /// @forBindingField define /// /// ## Command Definitions @@ -175,7 +176,7 @@ pub struct Define { pub bind: HashMap, #[serde(skip)] pub command: HashMap, - pub var: HashMap, + pub val: HashMap, } lazy_static! { @@ -190,11 +191,11 @@ impl Define { let mut resolved_var = HashMap::::new(); let mut errors: Vec = Vec::new(); - for def_block in input.var.into_iter().flatten() { - for (var, value) in def_block.into_iter() { - match value.resolve("`{var}` definition") { + for def_block in input.val.into_iter().flatten() { + for (val, value) in def_block.into_iter() { + match value.resolve("`{val}` definition") { Ok(x) => { - resolved_var.insert(var, x); + resolved_var.insert(val, x); } Err(mut e) => { errors.append(&mut e.errors); @@ -206,11 +207,11 @@ impl Define { for def in input.command.into_iter().flatten() { let id = def.get_ref().id.clone(); let span = id - .ok_or_else(|| RawError::RequiredField("`id` field".into())) - .context_range(&def.span()); + .ok_or_else(|| err("requires `id` field")) + .with_range(&def.span()); match span { Err(e) => errors.push(e.into()), - Ok(x) => match x.resolve("`id` field") { + Ok(x) => match x.resolve("requires `id`") { Err(mut e) => { errors.append(&mut e.errors); } @@ -224,11 +225,11 @@ impl Define { for def in input.bind.into_iter().flatten() { let id = def.get_ref().id.clone(); let span = id - .ok_or_else(|| RawError::RequiredField("`id` field".into())) - .context_range(&def.span()); + .ok_or_else(|| err("requires `id` field")) + .with_range(&def.span()); match span { Err(e) => errors.push(e.into()), - Ok(x) => match x.resolve("`id` field") { + Ok(x) => match x.resolve("`id`") { Err(mut e) => { errors.append(&mut e.errors); } @@ -249,16 +250,16 @@ impl Define { return Ok(Define { bind: resolved_bind, command: resolved_command, - var: resolved_var, + val: resolved_var, }); } } pub fn add_to_scope(&self, scope: &mut Scope) -> ResultVec<()> { - for (k, v) in self.var.iter() { + for (k, v) in self.val.iter() { v.require_constant()?; let val: Dynamic = v.clone().into(); - // TODO: add all of these to a `var.` value + // TODO: add all of these to a `val.` value scope.state.set_or_push(k, val); } return Ok(()); @@ -270,7 +271,7 @@ impl Define { let BindingReference(name) = default.as_ref(); let entry = self.bind.entry(name.clone()); let occupied_entry = match entry { - hash_map::Entry::Vacant(_) => Err(RawError::UndefinedVariable(name.clone()))?, + hash_map::Entry::Vacant(_) => Err(err!("{name}"))?, hash_map::Entry::Occupied(entry) => entry, }; let mut default_value; @@ -293,14 +294,14 @@ impl Define { return Ok(self .command .get(name) - .ok_or_else(|| RawError::UndefinedVariable(name.to_string()))? + .ok_or_else(|| err!("`{name}` is undefined"))? .without_id() .into()); } if BIND_REF.is_match(&exp) { - Err(RawError::Constraint( - "`bind.` reference in `default` field only".into(), - ))? + return Err(err( + "unexpected `bind.` reference; only valid inside `bind.default`", + ))?; } return Ok(Value::Expression(exp)); }); @@ -314,7 +315,7 @@ mod tests { #[test] fn simple_parsing() { let data = r#" - [[var]] + [[val]] y = "bill" [[bind]] @@ -328,15 +329,15 @@ mod tests { command = "runCommands" args.commands = ["foo", "bar"] - [[var]] + [[val]] joe = "bob" "#; let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); - assert_eq!(result.var.get("y").unwrap(), &Value::String("bill".into())); - assert_eq!(result.var.get("joe").unwrap(), &Value::String("bob".into())); + assert_eq!(result.val.get("y").unwrap(), &Value::String("bill".into())); + assert_eq!(result.val.get("joe").unwrap(), &Value::String("bob".into())); let foo = result.bind.get("foo").unwrap(); assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); let args = foo.args.as_ref().unwrap().clone().into_inner(); diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 609c52ef..ab63f548 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -9,7 +9,11 @@ use thiserror::Error; use toml::Spanned; use wasm_bindgen::prelude::*; -// TODO: properly handle `WhileTrying` (e.g. by having an outer type to prevent nesting) +// +// ---------------- Error Generation ---------------- +// + +// Functionality related to producing the basic `Error` objects used throughout this crate. #[derive(Debug, Error, Clone)] pub enum RawError { @@ -22,9 +26,20 @@ pub enum RawError { #[error("while parsing regex: {0}")] Regex(#[from] regex::Error), #[error("{0}")] - Static(&'static str), - #[error("{0}")] Dynamic(String), + #[error("{0}")] + Static(&'static str), +} + +#[macro_export] +macro_rules! err { + ( $($x:tt)* ) => { + crate::error::RawError::Dynamic(format!($($x)*)) + }; +} + +pub fn err(msg: &'static str) -> RawError { + return RawError::Static(msg); } #[wasm_bindgen] @@ -32,97 +47,139 @@ pub enum RawError { pub struct Error { #[source] pub(crate) error: RawError, - pub(crate) contexts: SmallVec<[String; 8]>, - pub(crate) ranges: SmallVec<[Position; 8]>, + pub(crate) contexts: SmallVec<[Context; 8]>, } #[derive(Debug, Clone)] -enum Position { - Rhai(rhai::Position), - Range(Range), +pub enum Context { + Dynamic(&'static str), // additional message content to include + Range(Range), // the location of an error in a file + RhaiPosition(rhai::Position), // the location of an error within an expression + + // TODO: use this context once when/if expressions have a known span + #[allow(dead_code)] + ExpressionRange(Range), // the location of an expression in a file } -#[wasm_bindgen] -#[derive(Debug, Clone, Error)] -#[error("first error: {}", .errors[0])] -pub struct ErrorSet { - pub(crate) errors: Vec, +/// A `Spannable` can be interpreted as a range of byte offsets +/// as stored by `toml::Spanned`. +pub trait Spannable { + fn range(&self) -> Option>; } -fn range_to_pos(range: Range, offsets: &StringOffsets) -> CharRange { - let start = offsets.utf8_to_char_pos(range.start); - let end = offsets.utf8_to_char_pos(range.end); - CharRange { start, end } +impl Spannable for Spanned { + fn range(&self) -> Option> { + Some(self.span()) + } } -// TODO: stopped working here -impl From> for Error { - fn from(value: Box) -> Self { - let error: Error = RawError::Dynamic(format!("{}", value)).into(); - // how to combine with info about surrounding range - // (if we have a range after this one use it; or should it be before?) - error.context_range(Position::Rhai(value.position())); +impl Spannable for Option> { + fn range(&self) -> Option> { + self.as_ref().map(|x| x.span()) } } -impl From for ErrorSet { - fn from(value: Error) -> Self { - return ErrorSet { - errors: vec![value], - }; +impl Spannable for Range { + fn range(&self) -> Option> { + return Some(self.clone()); } } -#[wasm_bindgen] -impl Error { - pub fn report(&self, content: &[u8]) -> ErrorReport { - let mut items = Vec::with_capacity(self.contexts.len() + 1); - let offsets: StringOffsets = StringOffsets::from_bytes(content); - items.push(match &self.error { - RawError::TomlParsing(toml) => ErrorReportItem { - message: Some(toml.message().into()), - range: toml.span().map(|r| range_to_pos(r, &offsets)), - }, - _ => ErrorReportItem { - message: Some(self.error.to_string()), - range: None, - }, - }); - for context in &self.contexts { - let item = match context { - Context::String(str) => ErrorReportItem { - message: Some(str.clone()), - range: None, - }, - Context::Range(range) => { - if *range == UNKNOWN_RANGE { - continue; - } - ErrorReportItem { - message: None, - range: Some(range_to_pos(range.clone(), &offsets)), - } - } - }; - items.push(item); +/// An object implementing `ErrorContext` can store additional context +/// about the error being returned. +pub trait ErrorContext +where + Self: Sized, +{ + type Error; + /// `with_context` accepts a `Context` which the object should store + fn with_context(self, context: Context) -> std::result::Result; + fn with_message(self, context: &'static str) -> std::result::Result { + return self.with_context(Context::Dynamic(context)); + } + fn with_range(self, context: &impl Spannable) -> std::result::Result { + if let Some(range) = context.range() { + return self.with_context(Context::Range(range)); + } else { + return self.with_context(Context::Range(UNKNOWN_RANGE)); + } + } + fn with_expression_range( + self, + context: &impl Spannable, + ) -> std::result::Result { + if let Some(range) = context.range() { + return self.with_context(Context::ExpressionRange(range)); + } else { + return self.with_context(Context::ExpressionRange(UNKNOWN_RANGE)); } - return ErrorReport { items }; + } + fn with_pos(self, context: rhai::Position) -> std::result::Result { + return self.with_context(Context::RhaiPosition(context)); } } -#[wasm_bindgen] -impl ErrorSet { - pub fn report(&self, content: &[u8]) -> Vec { - return self.errors.iter().map(|e| e.report(content)).collect(); +impl ErrorContext for Result { + type Error = Error; + fn with_context(self, context: Context) -> Result { + return match self { + Ok(x) => Ok(x), + Err(mut e) => { + e.contexts.push(context); + Err(Error { + error: e.error, + contexts: e.contexts, + }) + } + }; } } -#[derive(Debug, Clone)] -#[wasm_bindgen(getter_with_clone)] -pub struct ErrorReport { - pub items: Vec, +pub type Result = std::result::Result; + +impl> From for Error { + fn from(error: E) -> Self { + return Error { + error: error.into(), + contexts: SmallVec::new(), + }; + } +} + +impl From> for Error { + fn from(value: Box) -> Error { + let error = RawError::Dynamic(value.to_string()).into(); + let mut contexts = SmallVec::new(); + contexts.push(Context::RhaiPosition(value.position())); + return Error { error, contexts }; + } +} + +// +// ---------------- ErrorSet Generation ---------------- +// + +// Functionality related to the generation of ErrorSets; these track multiple errors +// produced across different locations in a parsed master keybinding file + +pub type ResultVec = std::result::Result; + +#[wasm_bindgen] +#[derive(Debug, Clone, Error)] +#[error("first error: {}", .errors[0])] +pub struct ErrorSet { + pub(crate) errors: Vec, } +impl From for ErrorSet { + fn from(value: Error) -> Self { + return ErrorSet { + errors: vec![value], + }; + } +} + +/// Compile an iterable of `ResultVec` to a single `ResultVec>` pub fn flatten_errors(errs: impl Iterator>) -> ResultVec> where T: std::fmt::Debug, @@ -140,36 +197,74 @@ where } } -#[wasm_bindgen] -#[derive(Debug, Clone)] -pub struct CharRange { - pub start: Pos, - pub end: Pos, +impl> From for ErrorSet { + fn from(error: E) -> Self { + let error: RawError = error.into(); + let error: Error = error.into(); + return error.into(); + } } -#[wasm_bindgen(getter_with_clone)] -#[derive(Debug, Clone)] -pub struct ErrorReportItem { - pub message: Option, - pub range: Option, +impl From> for ErrorSet { + fn from(value: Vec) -> Self { + return ErrorSet { errors: value }; + } } -#[derive(Debug, Clone)] -pub enum Context { - String(String), - Range(Range), +impl> ErrorContext for std::result::Result { + type Error = Error; + fn with_context(self, context: Context) -> Result { + return match self { + Ok(x) => Ok(x), + Err(e) => { + let mut contexts = SmallVec::new(); + contexts.push(context); + Err(Error { + error: e.into(), + contexts, + }) + } + }; + } } +impl ErrorContext for ResultVec { + type Error = ErrorSet; + fn with_context(self, context: Context) -> ResultVec { + return match self { + Ok(x) => Ok(x), + Err(mut errs) => { + errs.errors + .iter_mut() + .for_each(|e| e.contexts.push(context.clone())); + Err(errs) + } + }; + } +} + +// +// ---------------- Error Reporting ---------------- +// + +// While this trait might be useful for debugging it is not the main API through which +// errors are reported. It has to be implemented for `derive(Error)` to work impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::RawError> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { for context in &self.contexts { match context { - Context::String(str) => { + Context::Dynamic(str) => { write!(f, "{}\n", str)?; } Context::Range(range) => { write!(f, "byte range {:?}\n", range)?; } + Context::ExpressionRange(range) => { + write!(f, "byte range of expression {:?}\n", range)?; + } + Context::RhaiPosition(pos) => { + write!(f, "expression pos: {:?}\n", pos)?; + } } } self.error.fmt(f)?; @@ -177,132 +272,132 @@ impl fmt::Display for Error { } } -impl> From for Error { - fn from(error: E) -> Self { - return Error { - error: error.into(), - contexts: SmallVec::new(), - }; - } -} - -impl From> for Error {} - -impl> From for ErrorSet { - fn from(error: E) -> Self { - let error: RawError = error.into(); - let error: Error = error.into(); - return error.into(); +fn range_to_pos(range: &Range, offsets: &StringOffsets) -> CharRange { + let start; + let end; + if range == &UNKNOWN_RANGE { + start = offsets.utf8_to_char_pos(0); + end = offsets.utf8_to_char_pos(offsets.len()); + } else { + start = offsets.utf8_to_char_pos(range.start); + end = offsets.utf8_to_char_pos(range.end); } + CharRange { start, end } } -impl From> for ErrorSet { - fn from(value: Vec) -> Self { - return ErrorSet { errors: value }; +fn resolve_rhai_pos_from_expression_range( + rhai_pos: Option, + char_line_range: Option, +) -> Option { + if let (Some(rpos), Some(cl_range)) = (rhai_pos, &char_line_range) { + if let Some(line) = rpos.line() { + if line > 1 { + let char_line_start = Pos { + line: cl_range.start.line + line - 1, + col: cl_range.start.col + rpos.position().unwrap_or_default(), + }; + return Some(CharRange { + start: char_line_start, + end: char_line_start, + }); + } + } } + return char_line_range; } -pub fn constrain(msg: &str) -> Result { - return Err(RawError::Constraint(msg.into()))?; -} - -pub fn unexpected(msg: &'static str) -> Result { - return Err(RawError::Unexpected(msg))?; -} - -pub fn reserved(msg: &'static str) -> Result { - return Err(RawError::ReservedField(msg))?; -} - -// TODO: range - we select the most narrowest error, or the first -// such error if some don't overlap -// TODO: keep context string -// when reporting we don't split single Error into -// multiple diagnostics - -pub trait ErrorContext -where - Self: Sized, -{ - type RawError; - fn context(self, context: Context) -> std::result::Result; - fn context_str(self, context: impl Into) -> std::result::Result { - self.context(Context::String(context.into())) - } - fn context_range(self, context: &impl Spannable) -> std::result::Result { - if let Some(range) = context.range() { - return self.context(Context::Range(range)); +#[wasm_bindgen] +impl Error { + pub fn report(&self, content: &[u8]) -> ErrorReport { + let offsets: StringOffsets = StringOffsets::from_bytes(content); + let mut message_buf = String::new(); + let mut range = UNKNOWN_RANGE; + let mut char_line_range = None; + let mut rhai_pos = None; + match &self.error { + RawError::TomlParsing(toml) => { + message_buf.push_str(toml.message()); + char_line_range = toml.span().map(|r| range_to_pos(&r, &offsets)); + } + _ => message_buf.push_str(&self.error.to_string()), + }; + for context in &self.contexts { + match context { + Context::Dynamic(str) => message_buf.push_str(str), + Context::Range(new_range) => { + // usually the new range is the one we want to use *but* the old range + // is strictly more specific than the new one, we keep the old range + if !(range.len() < new_range.len() + && (new_range.contains(&range.start) || new_range.contains(&range.end))) + { + range = new_range.clone(); + let range_pos = range_to_pos(&range, &offsets); + char_line_range = Some(CharRange { + start: range_pos.start, + end: range_pos.end, + }); + } + } + Context::ExpressionRange(new_range) => { + // we can now resolve the `Context::RhaiPosition`, which is relative to + // the start of an expression, to a specific file location, because we + // have the range of the full expression. + char_line_range = Some(range_to_pos(&new_range, &offsets)); + char_line_range = + resolve_rhai_pos_from_expression_range(rhai_pos, char_line_range); + } + Context::RhaiPosition(pos) => { + // when we see a rhai range all we know is where, relative to the start + // of the expression the error was raised. We have to wait until a + // future iteration of this `for` loop when we find a specific file + // location where the expression begins. + rhai_pos = Some(pos.clone()); + } + }; + } + if let Some(cl_range) = char_line_range { + return ErrorReport { + message: message_buf, + range: cl_range, + }; } else { - return self.context(Context::Range(UNKNOWN_RANGE)); + return ErrorReport { + message: format!( + "Failed to find range location for the message {}", + message_buf + ), + range: CharRange::default(), + }; } } } -pub trait Spannable { - fn range(&self) -> Option>; -} - -impl Spannable for Spanned { - fn range(&self) -> Option> { - Some(self.span()) - } -} - -impl Spannable for Option> { - fn range(&self) -> Option> { - self.as_ref().map(|x| x.span()) - } -} - -impl Spannable for Range { - fn range(&self) -> Option> { - return Some(self.clone()); +#[wasm_bindgen] +impl ErrorSet { + pub fn report(&self, content: &[u8]) -> Vec { + return self.errors.iter().map(|e| e.report(content)).collect(); } } -impl> ErrorContext for std::result::Result { - type RawError = Error; - fn context(self, context: Context) -> Result { - return match self { - Ok(x) => Ok(x), - Err(e) => Err(Error { - error: e.into(), - contexts: vec![context], - }), - }; - } +#[wasm_bindgen] +#[derive(Debug, Clone)] +pub struct CharRange { + pub start: Pos, + pub end: Pos, } -impl ErrorContext for Result { - type RawError = Error; - fn context(self, context: Context) -> Result { - return match self { - Ok(x) => Ok(x), - Err(mut e) => { - e.contexts.push(context); - Err(Error { - error: e.error, - contexts: e.contexts, - }) - } +impl Default for CharRange { + fn default() -> Self { + return CharRange { + start: Pos { line: 0, col: 0 }, + end: Pos { line: 0, col: 0 }, }; } } -impl ErrorContext for ResultVec { - type RawError = ErrorSet; - fn context(self, context: Context) -> ResultVec { - return match self { - Ok(x) => Ok(x), - Err(mut errs) => { - errs.errors - .iter_mut() - .for_each(|e| e.contexts.push(context.clone())); - Err(errs) - } - }; - } +#[wasm_bindgen(getter_with_clone)] +#[derive(Debug, Clone)] +pub struct ErrorReport { + pub message: String, + pub range: CharRange, } - -pub type Result = std::result::Result; -pub type ResultVec = std::result::Result; diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 9f096235..f65e0e21 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -6,12 +6,11 @@ use std::collections::{HashMap, VecDeque}; use rhai::Dynamic; use serde::Serialize; -use toml::Spanned; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ - bind::command::Command, error::RawError, error::Result, error::ResultVec, - expression::value::Expanding, expression::value::Value, + bind::command::Command, err, error::Result, error::ResultVec, expression::value::Expanding, + expression::value::Value, }; /// @file expressions/index.md @@ -24,12 +23,12 @@ use crate::{ /// to any valid TOML object when the entire string is an expression /// /// ```toml -/// [[define.var]] +/// [[define.val]] /// action_priority = 3 /// /// [[bind]] /// # ...other fields here... -/// priority = "{{var.action_priority + 2}}" +/// priority = "{{val.action_priority + 2}}" /// /// # after expression evaluation, the above would evaluate to /// priority = 5 @@ -39,12 +38,12 @@ use crate::{ /// expression is interpolated into the string /// /// ```toml -/// [[define.var]] +/// [[define.val]] /// action_priority = 3 /// /// [[bind]] /// # ...other fields here... -/// name = "My cool action (priority {{var.action_priority + 2}})" +/// name = "My cool action (priority {{val.action_priority + 2}})" /// /// # after expression evaluation, the above would evaluate to /// name = "My cool action (priority 5)" @@ -71,8 +70,8 @@ use crate::{ /// Expressions that get evaluated at run time are clearly denoted as such with a ⚡ emoji. /// They are more expressive, and have access to the following values: /// -/// - Any field defined in a [`[[define.var]]`](/bindings/define) section. These variables -/// are all stored under the top-level `var.` object. +/// - Any field defined in a [`[[define.val]]`](/bindings/define) section. These variables +/// are all stored under the top-level `val.` object. /// - `code.editorHasSelection`: true if there is any selection, false otherwise /// - `code.editorHasMultipleSelections`: true if there are multiple selections, false /// otherwise @@ -95,7 +94,7 @@ use crate::{ #[wasm_bindgen] pub struct Scope { - pub(crate) asts: HashMap>, + pub(crate) asts: HashMap, engine: rhai::Engine, pub(crate) state: rhai::Scope<'static>, pub(crate) queues: HashMap>, @@ -120,17 +119,16 @@ impl Scope { self.state.set_or_push(k, v.clone()); } return Ok(obj.clone().map_expressions(&mut |expr| { - let ast = self.asts[&expr].get_ref(); - let result = self.engine.eval_ast_with_scope(&mut self.state, ast); - let value: rhai::Dynamic = match result { - Err(x) => Err(RawError::ExpressionEval(format!("{}", x)))?, - Ok(x) => x, - }; + let ast = &self.asts[&expr]; + let value: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; let result_value: Value = value.clone().try_into()?; return Ok(result_value); })?); } + // TODO: revelation, we don't actually have a way to get an expressions' precise + // position because of how parsing works. *MAYBE* we could write a custom + // deserializer or value::Value, but that seems very complex pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { x.clone().map_expressions(&mut |expr| { let ast = self.engine.compile_expression(expr.clone())?; @@ -155,7 +153,7 @@ impl Scope { pub fn set(&mut self, name: String, value: JsValue) -> Result<()> { let toml: toml::Value = match serde_wasm_bindgen::from_value(value) { - Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, + Err(e) => Err(err!("{}", e))?, Ok(x) => x, }; let val: Value = toml.try_into()?; @@ -168,22 +166,22 @@ impl Scope { return Ok(self .state .remove(&name) - .ok_or_else(|| RawError::UndefinedVariable(name))?); + .ok_or_else(|| err!("`{name}` is undefined"))?); } pub fn get(&self, name: String) -> Result { let x: &rhai::Dynamic = self .state .get(&name) - .ok_or_else(|| RawError::UndefinedVariable(name))?; + .ok_or_else(|| err!("`{name}` is undefined"))?; let x: Value = match x.clone().try_cast_result() { - Err(e) => Err(RawError::Rhai(format!("{}", e)))?, + Err(e) => Err(err!("{x} is not a valid JSON value"))?, Ok(x) => x, }; let x: toml::Value = x.into(); let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return match x.serialize(&to_json) { - Err(e) => Err(RawError::JsSerialization(format!("{}", e)))?, + Err(e) => Err(err!("JSON serialization error: {e}"))?, Ok(x) => Ok(x), }; } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index cfcf7857..7b4a97d9 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -6,13 +6,13 @@ use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; -use std::fmt::Display; +use std::io; use std::io::Write; -use std::{default, io}; use toml::Spanned; -use crate::error::{ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; -use crate::util::{Merging, Plural, Required, Resolving}; +use crate::err; +use crate::error::{ErrorContext, ErrorSet, Result, ResultVec, flatten_errors}; +use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; // // ---------------- `Value` ---------------- @@ -39,6 +39,12 @@ pub enum Value { Expression(String), } +impl Default for Value { + fn default() -> Self { + return Value::Table(BTreeMap::new()); + } +} + impl From for Dynamic { fn from(value: Value) -> Self { return match value { @@ -63,7 +69,7 @@ impl From for Dynamic { } impl TryFrom for Value { - type RawError = crate::error::Error; + type Error = crate::error::Error; // TODO: this is currently almost certainly quite inefficient (we clone arrays and // maps), but we can worry about optimizing this later fn try_from(value: Dynamic) -> Result { @@ -98,9 +104,7 @@ impl TryFrom for Value { .to_string(), )); } else { - Err(RawError::Constraint(format!( - "usable script value; but {value} is unusable" - )))? + return Err(err!("{value} cannot be interpreted as a valid TOML value"))?; } } } @@ -110,17 +114,16 @@ lazy_static! { } impl TryFrom for Value { - type RawError = ErrorSet; + type Error = ErrorSet; fn try_from(value: toml::Value) -> ResultVec { return Ok(match value { toml::Value::Boolean(x) => Value::Boolean(x), toml::Value::Float(x) => Value::Float(x), toml::Value::Integer(x) => Value::Integer({ if x > (std::f64::MAX as i64) || x < (std::f64::MIN as i64) { - return Err(RawError::Constraint(format!( - "{x} cannot be expressed as a 64-bit floating point number." - )) - .into()); + return Err(err!( + "{x} cannot be expressed as a 64-bit floating point number.", + ))?; } else { x.clone() as i32 } @@ -227,14 +230,16 @@ impl Merging for Value { } impl Resolving for Value { - fn resolve(self, _name: impl Into) -> ResultVec { + fn resolve(self, _name: &'static str) -> ResultVec { Ok(self) } } impl Resolving for Value { - fn resolve(self, name: impl Into) -> ResultVec { - self.require_constant().context_str(name)?; + fn resolve(self, name: &'static str) -> ResultVec { + self.require_constant() + .with_message("for ") + .with_message(name)?; return Ok(self.into()); } } @@ -266,9 +271,8 @@ pub trait Expanding { where Self: Sized + Clone, { - self.clone().map_expressions(&mut |e| { - Err(RawError::Unresolved(format!("Unresolved expression {e}",)))? - })?; + self.clone() + .map_expressions(&mut |e| Err(err!("Unresolved expression {e}"))?)?; return Ok(()); } } @@ -346,7 +350,7 @@ impl Expanding for Spanned { let span = self.span(); Ok(Spanned::new( span.clone(), - self.into_inner().map_expressions(f).context_range(&span)?, + self.into_inner().map_expressions(f).with_range(&span)?, )) } } @@ -442,13 +446,13 @@ impl<'e, T> TryFrom for TypedValue where T: Deserialize<'e> + Serialize + std::fmt::Debug, { - type RawError = ErrorSet; + type Error = ErrorSet; fn try_from(value: toml::Value) -> ResultVec> { io::stdout().flush().unwrap(); let val: Value = value.try_into()?; io::stdout().flush().unwrap(); - return match val.require_constant("") { + return match val.require_constant() { Err(_) => Ok(TypedValue::Variable(val)), Ok(_) => { let toml: toml::Value = val.into(); @@ -526,6 +530,18 @@ impl From> for bool { } } +impl From>> for Plural +where + T: Serialize + std::fmt::Debug + Clone, +{ + fn from(value: TypedValue>) -> Self { + return match value { + TypedValue::Constant(x) => x, + TypedValue::Variable(value) => panic!("Unresolved variable value: {value:?}"), + }; + } +} + impl From> for Value where T: Into + Serialize + std::fmt::Debug, @@ -545,27 +561,42 @@ where } } -impl Resolving for TypedValue +impl Resolving for TypedValue where - T: Serialize + std::fmt::Debug, + U: LeafValue, + T: Serialize + std::fmt::Debug + Resolving, TypedValue: Expanding + Clone + Into, { - fn resolve(self, name: impl Into) -> ResultVec { + fn resolve(self, name: &'static str) -> ResultVec { self.require_constant() - .context_str(format!("for {}", name.into()))?; - return Ok(self.into()); + .with_message("for ") + .with_message(name)?; + let constant = self.into(); + return constant.resolve(name); } } impl Resolving> for TypedValue where - T: Serialize + std::fmt::Debug, + T: LeafValue + Serialize + std::fmt::Debug, { - fn resolve(self, _name: impl Into) -> ResultVec> { + fn resolve(self, name: &'static str) -> ResultVec> { return Ok(self); } } +impl Resolving> for Option>> +where + T: Default + Serialize + std::fmt::Debug, +{ + fn resolve(self, _name: &'static str) -> ResultVec> { + return match self { + Some(x) => Ok(x.into_inner()), + None => Ok(TypedValue::default()), + }; + } +} + impl Merging for TypedValue { fn coalesce(self, new: Self) -> Self { return new; diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 9c07d12a..0f9330dd 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -72,7 +72,7 @@ /// key = "h" /// args.to = "left" /// -/// [[define.var]] +/// [[define.val]] /// foo = 1 /// /// [[bind]] @@ -82,6 +82,9 @@ /// args.to = "right" /// args.value = "{{foo+1}}" /// ``` +#[allow(unused_imports)] +use log::info; + use crate::bind::{Binding, BindingInput}; use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; @@ -157,7 +160,7 @@ impl KeyFile { .into_iter() .map(Binding::new) .collect::>>() - .context_range(&span); + .with_range(&span); match items { Ok(x) => x, Err(mut e) => { @@ -210,13 +213,14 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { #[cfg(test)] mod tests { use super::*; + use crate::expression::value::Value; use std::collections::BTreeMap; use test_log::test; #[test] fn parse_example() { let data = r#" - [[define.var]] + [[define.val]] foo = "bar" [[bind]] @@ -230,31 +234,30 @@ mod tests { command = "cursorLeft" "#; - let result = parse_string(data); - let items = result.file.unwrap(); + let result = parse_bytes_helper(data.as_bytes()).unwrap(); - assert_eq!(items.bind[0].key, "l"); - assert_eq!(items.bind[0].commands[0].command, "cursorRight"); - assert_eq!(items.bind[1].key, "h"); - assert_eq!(items.bind[1].commands[0].command, "cursorLeft"); + assert_eq!(result.bind[0].key, "l"); + assert_eq!(result.bind[0].commands[0].command, "cursorRight"); + assert_eq!(result.bind[1].key, "h"); + assert_eq!(result.bind[1].commands[0].command, "cursorLeft"); } #[test] fn resolve_bind_and_command() { let data = r#" - [[define.var]] + [[define.val]] foo_string = "bizbaz" [[define.command]] id = "run_shebang" command = "shebang" args.a = 1 - args.b = "{{var.foo_string}}" + args.b = "{{val.foo_string}}" [[define.bind]] id = "whole_shebang" - name = "the whole shebang" + doc.name = "the whole shebang" command = "runCommands" args.commands = ["{{command.run_shebang}}", "bar"] @@ -265,14 +268,14 @@ mod tests { let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); - assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key, "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, Value::Table(BTreeMap::from([ ("a".into(), Value::Integer(1)), - ("b".into(), Value::Expression("var.foo_string".into())), + ("b".into(), Value::Expression("val.foo_string".into())), ])) ); assert_eq!(result.bind[0].commands[1].command, "bar"); @@ -286,7 +289,7 @@ mod tests { id = "run_shebang" command = "shebang" args.a = 1 - args.b = "{{var.foo_string}}" + args.b = "{{val.foo_string}}" [[define.bind]] id = "a" @@ -300,20 +303,20 @@ mod tests { [[bind]] default = "{{bind.b}}" - name = "the whole shebang" + doc.name = "the whole shebang" key = "a" "#; let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); - assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); + assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key, "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, Value::Table(BTreeMap::from([ ("a".into(), Value::Integer(1)), - ("b".into(), Value::Expression("var.foo_string".into())), + ("b".into(), Value::Expression("val.foo_string".into())), ])) ); assert_eq!(result.bind[0].commands[1].command, "bar"); @@ -325,7 +328,7 @@ mod tests { [[bind]] foreach.key = ["{{keys(`[0-9]`)}}"] key = "c {{key}}" - name = "update {{key}}" + doc.name = "update {{key}}" command = "foo" args.value = "{{key}}" "#; @@ -338,10 +341,7 @@ mod tests { assert_eq!(result.bind.len(), 10); for i in 0..9 { - assert_eq!( - result.bind[i].name.as_ref().unwrap().clone(), - expected_name[i] - ); + assert_eq!(result.bind[i].doc.name, expected_name[i]); assert_eq!( result.bind[i].commands[0].args, Value::Table(BTreeMap::from([( @@ -357,20 +357,17 @@ mod tests { let data = r#" [[bind]] foreach.key = ["{{keys(`[0-9]`)}}"] - name = "update {{key}}" + doc.name = "update {{key}}" command = "foo" args.value = "{{key}}" "#; // TODO: ensure that a proper span is shown here let result = KeyFile::new(toml::from_str::(data).unwrap()); - let report = result.unwrap_err().report(data); - assert_eq!( - report[0].items[0].message, - Some("requires `key` field".to_string()) - ); - assert_eq!(report[0].items[1].range.as_ref().unwrap().start.line, 1); - assert_eq!(report[0].items[1].range.as_ref().unwrap().end.line, 1); + let report = result.unwrap_err().report(data.as_bytes()); + assert_eq!(report[0].message, "`key` field is required".to_string()); + assert_eq!(report[0].range.start.line, 1); + assert_eq!(report[0].range.end.line, 1); } // TODO: write a test for required field `key` and ensure the span diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 904c1584..be1bb632 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -5,7 +5,9 @@ use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use toml::{Spanned, Value}; -use crate::error::{RawError, ErrorContext, Error, Result, ResultVec, flatten_errors}; +use crate::err; +use crate::error::{Error, ErrorContext, Result, ResultVec, flatten_errors}; +use crate::expression::value::TypedValue; /// The `Merging` trait allows us to combine two versions of an object according to /// two different approaches (`coalesce` or `merge`). @@ -23,12 +25,15 @@ impl Merging for toml::Table { fn coalesce(self, new: Self) -> Self { return new; } - fn merge(self, mut new: Self) -> Self { - let pairs = self.into_iter().map(|(k, v)| match new.remove(&k) { + // BUG!!!: we need to add the new keys that aren't in self to `pairs` + fn merge(self, new: Self) -> Self { + let (mut to_merge, to_append): (toml::Table, toml::Table) = + new.into_iter().partition(|(k, _)| self.get(k).is_some()); + let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { Some(new_v) => (k, v.merge(new_v)), None => (k, v), }); - return pairs.collect(); + return pairs.chain(to_append.into_iter()).collect(); } } @@ -36,12 +41,15 @@ impl Merging for BTreeMap { fn coalesce(self, new: Self) -> Self { return new; } - fn merge(self, mut new: Self) -> Self { - let pairs = self.into_iter().map(|(k, v)| match new.remove(&k) { + // BUG!!!: we need to add the new keys that aren't in self to `pairs` + fn merge(self, new: Self) -> Self { + let (mut to_merge, to_append): (BTreeMap<_, _>, BTreeMap<_, _>) = + new.into_iter().partition(|(k, _)| self.get(k).is_some()); + let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { Some(new_v) => (k, v.merge(new_v)), None => (k, v), }); - return pairs.collect(); + return pairs.chain(to_append.into_iter()).collect(); } } @@ -110,39 +118,71 @@ impl Merging for bool { } } +#[macro_export] +macro_rules! resolve { + ($x:expr, $field:ident) => { + crate::util::Resolving::resolve(($x).$field, stringify!($field)) + }; +} + /// `Resolving` objects implement `resolve` which removes book-keeping objects related to /// the parsing an object (e.g. toml::Span), and returns a more ergonomic object -/// representations useful for downstream operations that don't care about these +/// representation useful for downstream operations that don't care about these /// book-keeping objects. pub trait Resolving { - fn resolve(self, name: impl Into) -> ResultVec; + fn resolve(self, name: &'static str) -> ResultVec; } +pub(crate) trait LeafValue {} + +impl LeafValue for String {} +impl LeafValue for f64 {} +impl LeafValue for i32 {} +impl LeafValue for bool {} +impl LeafValue for Plural where T: LeafValue + Clone {} +impl LeafValue for Vec where T: LeafValue + Clone {} + impl Resolving for Spanned where T: Resolving, { - fn resolve(self, name: impl Into) -> ResultVec { + fn resolve(self, name: &'static str) -> ResultVec { let span = self.span(); - Ok(self.into_inner().resolve(name).context_range(&span)?) + Ok(self.into_inner().resolve(name).with_range(&span)?) } } -impl Resolving> for Option +impl Resolving for T +where + T: LeafValue, +{ + fn resolve(self, _name: &'static str) -> ResultVec { + return Ok(self); + } +} + +impl Resolving for Option where T: Resolving, + U: Default + LeafValue, { - fn resolve(self, name: impl Into) -> ResultVec> { + fn resolve(self, name: &'static str) -> ResultVec { match self { - Some(x) => Ok(Some(x.resolve(name)?)), - None => Ok(None), + Some(x) => x.resolve(name), + None => Ok(U::default()), } } } -impl Resolving for String { - fn resolve(self, _name: impl Into) -> ResultVec { - return Ok(self); +impl Resolving> for Option +where + T: Resolving, +{ + fn resolve(self, name: &'static str) -> ResultVec> { + match self { + Some(x) => Ok(Some(x.resolve(name)?)), + None => Ok(None), + } } } @@ -160,7 +200,7 @@ impl<'de, T> TryFrom> for Required where T: Deserialize<'de>, { - type RawError = Error; + type Error = Error; fn try_from(value: Option) -> Result { match value { None => Ok(Required::DefaultValue), @@ -173,9 +213,9 @@ impl Resolving for Required where T: Resolving, { - fn resolve(self, name: impl Into) -> ResultVec { + fn resolve(self, name: &'static str) -> ResultVec { match self { - Required::DefaultValue => Err(RawError::RequiredField(name.into()))?, + Required::DefaultValue => Err(err!("`{name}` field is required"))?, Required::Value(x) => x.resolve(name), } } @@ -217,28 +257,40 @@ impl Required { } } +#[derive(Deserialize, Debug, Clone)] +#[serde(untagged)] +pub enum RawPlural { + Zero, + One(T), + Many(Vec), +} + // TODO: use `try_from` to improve error messages #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)] -#[serde(from = "Vec", into = "Vec")] +#[serde(from = "RawPlural", into = "Vec")] pub struct Plural(pub(crate) Vec) where T: Clone; -impl From> for Plural +impl From> for Plural where T: Clone, { - fn from(values: Vec) -> Self { - return Plural(values); + fn from(values: RawPlural) -> Self { + return match values { + RawPlural::Zero => Plural(vec![]), + RawPlural::One(x) => Plural(vec![x]), + RawPlural::Many(xs) => Plural(xs), + }; } } -impl From for Plural +impl From> for Vec where T: Clone, { - fn from(value: T) -> Self { - return Plural(vec![value]); + fn from(value: Plural) -> Self { + return value.0; } } @@ -251,25 +303,13 @@ where } } -impl From> for Vec -where - T: Clone, -{ - fn from(value: Plural) -> Self { - return value.0; - } -} - impl Resolving> for Plural where T: Clone + Resolving + std::fmt::Debug, U: std::fmt::Debug, { - fn resolve(self, name: impl Into) -> ResultVec> { - let name = name.into(); - Ok(flatten_errors( - self.0.into_iter().map(|x| x.resolve(name.clone())), - )?) + fn resolve(self, name: &'static str) -> ResultVec> { + Ok(flatten_errors(self.0.into_iter().map(|x| x.resolve(name)))?) } } From cd00f673ca8b63e0d7c74a61489965a119e95515 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 20 Sep 2025 11:10:26 -0400 Subject: [PATCH 50/79] cleanup / update notes Created using spr 1.3.6-beta.1 --- notes.md | 33 +++++--- src/rust/parsing/src/error.rs | 6 ++ src/rust/parsing/src/util.rs | 144 +++++++++++++++++++--------------- 3 files changed, 108 insertions(+), 75 deletions(-) diff --git a/notes.md b/notes.md index 68ae85b8..02646555 100644 --- a/notes.md +++ b/notes.md @@ -132,39 +132,37 @@ Integration test debugging: - [X] write some type-script unit tests - [ ] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - - [ ] re-organize the code into smaller units + - [X] re-organize the code into smaller units - [X] bind is way to big start by breaking that up - - [ ] organize order of definitions in files (e.g. join separate `impl` + - [X] organize order of definitions in files (e.g. join separate `impl` segments) - [X] `bind` - [X] define - [X] value - [X] validation - [X] foreach - - [ ] error + - [X] error - [X] expression - [X] file - [X] lib - - [~] util + - [X] util - [X] replace IndexMap with BTreeMap - [X] update documentation of `bind`, `define` and `expressions` - [X] refactor plural to use `into` / `from` Vec - [X] update documentation rendering pipeline - - [ ] error reporting is still a little finicky - - [ ] properly inject Rhai expression range into errors + - [X] error reporting is still a little finicky + - [X] properly inject Rhai expression range into errors - [X] could probably make what is part of the same error more explicit - [X] reduce types of errors and tie error message string more explicitly to name of enum variant - - [ ] fix and test command queues implementation (avoid so much copying) - - [ ] support spans for expressions - - [ ] re-run tests + - [ ] get error reporting working in javascript again - [ ] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` - [ ] improve expression evaluation - [ ] support expressions in `foreach` resolution - [ ] check if each AST has a `foreach` variable and resolve it - [ ] allow for `var` evaluation in parse-time expressions - - [ ] move all bare variables in an expression to `code.` object + - [ ] move all bare variables in an expression to `key.` or `code.` object - [ ] implement support for `all` functions: - [ ] `{{all_prefixes()}}` - [ ] `{{all_modes()}}` @@ -192,6 +190,10 @@ Integration test debugging: - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause - [ ] re-implement master-key.do + - [ ] fix and test command queues implementation (avoid copying) + - [ ] guess: don't have special command queue field + - [ ] support accessing values by their path (`val.foo`, `key.count`) + from javascript - [ ] transfer scope state from TS to rust Scope object - [ ] properly handle command queues (no controlled by rust) - [ ] unit tests @@ -209,7 +211,16 @@ Integration test debugging: - [ ] create data types to generate warnings/hints for old/unused fields - [ ] test this on the old version of larkin.toml - [ ] actually replace javascript behavior with rust functions (replace `dod`) - - [ ] replace `setFlag` with `updateDefine` + - [ ] replace `setFlag` with `updateDefine` (or something like that) + - [ ] improve error reporting in expressions + - [ ] support spans for expressions + - [ ] create a `SpannedValue` that tracks spans + - [ ] try to implement with just the Span for expressions tracked + - [ ] BUT this probably has to be for all variants, to avoid errors + - [ ] parse as `SpannedValue` instead of `toml::Value` + - [ ] inject Span into `Expression` + - [ ] inject expression spans and rhai positions into error contexts + - [ ] test that expressions spans properly resolve - [ ] CI - [x] setup CI unit tests for rust - [x] setup rust coverage diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index ab63f548..6691be7e 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -104,6 +104,8 @@ where return self.with_context(Context::Range(UNKNOWN_RANGE)); } } + // TODO: use this once we have ranges for expressions + #[allow(dead_code)] fn with_expression_range( self, context: &impl Spannable, @@ -114,6 +116,8 @@ where return self.with_context(Context::ExpressionRange(UNKNOWN_RANGE)); } } + // TODO: use this once we have ranges for expressions + #[allow(dead_code)] fn with_pos(self, context: rhai::Position) -> std::result::Result { return self.with_context(Context::RhaiPosition(context)); } @@ -308,6 +312,8 @@ fn resolve_rhai_pos_from_expression_range( #[wasm_bindgen] impl Error { + /// `report` is how we generate legible annotations + /// of *.mk.toml file errors in typescript pub fn report(&self, content: &[u8]) -> ErrorReport { let offsets: StringOffsets = StringOffsets::from_bytes(content); let mut message_buf = String::new(); diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index be1bb632..3c4613d9 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -9,6 +9,10 @@ use crate::err; use crate::error::{Error, ErrorContext, Result, ResultVec, flatten_errors}; use crate::expression::value::TypedValue; +// +// ---------------- Merging ---------------- +// + /// The `Merging` trait allows us to combine two versions of an object according to /// two different approaches (`coalesce` or `merge`). pub trait Merging { @@ -118,6 +122,74 @@ impl Merging for bool { } } +impl Merging for Option { + fn merge(self, new: Self) -> Self { + return match new { + Some(newval) => match self { + Some(oldval) => Some(oldval.merge(newval)), + None => Some(newval), + }, + None => self, + }; + } + + fn coalesce(self, new: Self) -> Self { + return new.or(self); + } +} + +impl Merging for String { + fn merge(self, new: Self) -> Self { + return new; + } + fn coalesce(self, new: Self) -> Self { + return new; + } +} + +impl Merging for toml::Value { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, new: Self) -> Self { + match new { + Value::Array(new_values) => match self { + Value::Array(old_values) => { + let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); + let mut new_iter = new_values.iter(); + let mut old_iter = old_values.iter(); + loop { + let new_item = new_iter.next(); + let old_item = old_iter.next(); + if let Some(new_val) = new_item { + if let Some(old_val) = old_item { + result.push(old_val.clone().merge(new_val.clone())); + } else { + result.push(new_val.clone()); + } + } else if let Some(old_val) = old_item { + result.push(old_val.clone()); + } else { + break; + } + } + Value::Array(result) + } + _ => Value::Array(new_values), + }, + Value::Table(new_kv) => match self { + Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), + _ => Value::Table(new_kv), + }, + _ => new, + } + } +} + +// +// ---------------- Resolving ---------------- +// + #[macro_export] macro_rules! resolve { ($x:expr, $field:ident) => { @@ -186,6 +258,10 @@ where } } +// +// ---------------- Required values ---------------- +// + /// required values represent a value that cannot be missing in a keybinding object after /// resolving all user defined defaults. #[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone)] @@ -257,6 +333,10 @@ impl Required { } } +// +// ---------------- Plural values ---------------- +// + #[derive(Deserialize, Debug, Clone)] #[serde(untagged)] pub enum RawPlural { @@ -312,67 +392,3 @@ where Ok(flatten_errors(self.0.into_iter().map(|x| x.resolve(name)))?) } } - -impl Merging for Option { - fn merge(self, new: Self) -> Self { - return match new { - Some(newval) => match self { - Some(oldval) => Some(oldval.merge(newval)), - None => Some(newval), - }, - None => self, - }; - } - - fn coalesce(self, new: Self) -> Self { - return new.or(self); - } -} - -impl Merging for String { - fn merge(self, new: Self) -> Self { - return new; - } - fn coalesce(self, new: Self) -> Self { - return new; - } -} - -impl Merging for toml::Value { - fn coalesce(self, new: Self) -> Self { - return new; - } - fn merge(self, new: Self) -> Self { - match new { - Value::Array(new_values) => match self { - Value::Array(old_values) => { - let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); - let mut new_iter = new_values.iter(); - let mut old_iter = old_values.iter(); - loop { - let new_item = new_iter.next(); - let old_item = old_iter.next(); - if let Some(new_val) = new_item { - if let Some(old_val) = old_item { - result.push(old_val.clone().merge(new_val.clone())); - } else { - result.push(new_val.clone()); - } - } else if let Some(old_val) = old_item { - result.push(old_val.clone()); - } else { - break; - } - } - Value::Array(result) - } - _ => Value::Array(new_values), - }, - Value::Table(new_kv) => match self { - Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), - _ => Value::Table(new_kv), - }, - _ => new, - } - } -} From 32184e84c0beb10d1d427e6dafd873fcd9639731 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 20 Sep 2025 15:56:03 -0400 Subject: [PATCH 51/79] added `tags` field to `[[bind]]` Created using spr 1.3.6-beta.1 --- notes.md | 4 +-- src/extension/keybindings/index.ts | 50 +++++++++------------------- src/extension/keybindings/parsing.ts | 3 -- src/rust/parsing/src/bind.rs | 23 ++++++++++++- src/rust/parsing/src/error.rs | 11 ++++++ 5 files changed, 51 insertions(+), 40 deletions(-) diff --git a/notes.md b/notes.md index 02646555..a84b4ae6 100644 --- a/notes.md +++ b/notes.md @@ -155,8 +155,8 @@ Integration test debugging: - [X] could probably make what is part of the same error more explicit - [X] reduce types of errors and tie error message string more explicitly to name of enum variant - - [ ] get error reporting working in javascript again - - [ ] implement support for tags on `bind` (for filter them) + - [X] get error reporting working in javascript again + - [X] implement support for tags on `bind` (for filter them) - [ ] implement support for `skipWhen` in `command` - [ ] improve expression evaluation - [ ] support expressions in `foreach` resolution diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 4ea94d2f..ca121233 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -649,40 +649,22 @@ async function validateKeybindings(file: vscode.Uri, fileData?: Uint8Array) { if (parsed.errors) { const diagnosticItems: vscode.Diagnostic[] = []; for (const error of parsed.errors) { - let message = ''; - let firstMessage = true; - for (const item of error.items) { - if (item.message) { - message += item.message + '\n'; - } - if (item.range) { - if (message.length > 0) { - diagnosticItems.push( - new vscode.Diagnostic( - new vscode.Range( - new vscode.Position( - item.range.start.line, - item.range.start.col, - ), - new vscode.Position( - item.range.end.line, - item.range.end.col, - ), - ), - message, - firstMessage ? - vscode.DiagnosticSeverity.Error : - vscode.DiagnosticSeverity.Hint, - ), - ); - firstMessage = false; - message = ''; - } - } - } - if (message) { - diagnosticItems[diagnosticItems.length - 1].message += message; - } + diagnosticItems.push( + new vscode.Diagnostic( + new vscode.Range( + new vscode.Position( + error.range.start.line, + error.range.start.col, + ), + new vscode.Position( + error.range.end.line, + error.range.end.col, + ), + ), + error.message, + vscode.DiagnosticSeverity.Error, + ), + ); } diagnostics.set(file, diagnosticItems); } else { diff --git a/src/extension/keybindings/parsing.ts b/src/extension/keybindings/parsing.ts index 4c3f30a1..065acf9e 100644 --- a/src/extension/keybindings/parsing.ts +++ b/src/extension/keybindings/parsing.ts @@ -15,7 +15,6 @@ export const INPUT_CAPTURE_COMMANDS = [ 'search', ]; - /** * @bindingField header * @description top-level properties of the binding file @@ -307,7 +306,6 @@ export const doArgs = bindingCommand.array().refine( ); export type DoArgs = z.infer; - // TODO: the errors are not very informative if we transform the result so early in this // way; we need to keep this as close as possible to the form in the raw file export const bindingItem = z. @@ -341,7 +339,6 @@ export const bindingItem = z. strict(); export type BindingItem = z.output; - export const bindingDefault = z.object({ id: z.string().regex(/(^$|[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*)/), default: rawBindingItem.partial().optional(), diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 17066f39..08c6399c 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -159,6 +159,14 @@ pub struct BindingInput { /// an argument. repeat: Option>>, + /// @forBindingField bind + /// + /// - `tags`: An array of strings used to characterize the behavior of the binding. They + /// have no inherent meaning but are often used when filtering which commands in a call + /// to [`master-key.replayFromHistory`](/commands/replayFromHistory/) can be replayed. + #[serde(default = "span_plural_default")] + tags: Spanned>>, + /// @forBindingField bind /// /// - `doc`: Documentation for this keybinding. None of the fields of this object @@ -229,6 +237,7 @@ impl BindingInput { prefixes: self.prefixes.clone(), finalKey: self.finalKey.clone(), repeat: self.repeat.clone(), + tags: self.tags.clone(), doc: self.doc.clone(), }; } @@ -252,6 +261,7 @@ impl Merging for BindingInput { prefixes: self.prefixes.coalesce(y.prefixes), finalKey: self.finalKey.coalesce(y.finalKey), repeat: self.repeat.coalesce(y.repeat), + tags: self.tags.coalesce(y.tags), doc: self.doc.merge(y.doc), } } @@ -271,6 +281,7 @@ impl Expanding for BindingInput { self.prefixes.is_constant(), self.finalKey.is_constant(), self.repeat.is_constant(), + self.tags.is_constant(), self.doc.is_constant(), ] .into_iter() @@ -327,6 +338,10 @@ impl Expanding for BindingInput { errors.append(&mut e.errors); None }), + tags: self.tags.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Spanned::new(UNKNOWN_RANGE, TypedValue::default()) + }), doc: self.doc.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); None @@ -518,6 +533,7 @@ pub struct Binding { pub prefixes: Vec, pub finalKey: bool, pub(crate) repeat: TypedValue, + pub tags: Vec, pub doc: BindingDoc, } @@ -548,6 +564,7 @@ impl Binding { prefixes: resolve!(input, prefixes)?, finalKey: resolve!(input, finalKey)?, repeat: resolve!(input, repeat)?, + tags: resolve!(input, tags)?, doc: resolve!(input, doc)?, }); } @@ -613,6 +630,7 @@ mod tests { prefixes = "c" finalKey = true repeat = "{{2+c}}" + tags = ["foo", "bar"] doc.name = "foo" doc.description = "foo bar bin" doc.hideInPalette = false @@ -666,6 +684,9 @@ mod tests { let finalKey: bool = resolve!(result, finalKey).unwrap(); assert_eq!(finalKey, true); + let tags: Vec = resolve!(result, tags).unwrap(); + assert_eq!(tags, ["foo".to_string(), "bar".to_string()]); + let doc = result.doc.unwrap(); let name: String = resolve!(doc, name).unwrap(); assert_eq!(name, "foo"); @@ -860,7 +881,7 @@ mod tests { args.value = "with-{{b}}" "#; - let mut result = toml::from_str::(data).unwrap(); + let result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 6691be7e..fa80904d 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -407,3 +407,14 @@ pub struct ErrorReport { pub message: String, pub range: CharRange, } + +#[wasm_bindgen] +impl ErrorReport { + #[wasm_bindgen(constructor)] + pub fn new() -> Self { + return ErrorReport { + message: String::from(""), + range: CharRange::default(), + }; + } +} From 37a6e757b41b4ead8479b0b45ae43676c9c2d2c5 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 20 Sep 2025 17:13:10 -0400 Subject: [PATCH 52/79] support `skipWhen` in `runCommands` items Created using spr 1.3.6-beta.1 --- notes.md | 4 +- src/rust/parsing/src/bind/command.rs | 132 +++++++++++++++++++++-- src/rust/parsing/src/expression/value.rs | 16 ++- 3 files changed, 136 insertions(+), 16 deletions(-) diff --git a/notes.md b/notes.md index a84b4ae6..9ba44ffa 100644 --- a/notes.md +++ b/notes.md @@ -156,8 +156,9 @@ Integration test debugging: - [X] reduce types of errors and tie error message string more explicitly to name of enum variant - [X] get error reporting working in javascript again + - [ ] remove all compile warnings - [X] implement support for tags on `bind` (for filter them) - - [ ] implement support for `skipWhen` in `command` + - [X] implement support for `skipWhen` in `command` - [ ] improve expression evaluation - [ ] support expressions in `foreach` resolution - [ ] check if each AST has a `foreach` variable and resolve it @@ -169,7 +170,6 @@ Integration test debugging: - [ ] `{{all_modes_but(["not_me", "or_me"])}}` - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - - [ ] support `skipWhen` - [ ] flatten all nested `runCommands` calls - [ ] `skipWhen` will have to be propagated/merged to children - [ ] check constraints diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 298dcb68..4299c12b 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -1,3 +1,6 @@ +#[allow(unused_imports)] +use log::info; + use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use toml::Spanned; @@ -31,17 +34,19 @@ use crate::{ pub struct CommandInput { // should only be `Some` in context of `Define(Input)` pub(crate) id: Option>>, - /// @forBindingField bind @order 15 + /// @forBindingField bind + /// @order 15 /// - ❗`command`: as per the top level `command` field, this is a the command you wish to /// run. pub command: Spanned>>, - /// @forBindingField bind @order 15 + /// @forBindingField bind + /// @order 15 /// - ⚡ `args`: as per the top level `args` field. Can include /// runtime [expressions](/expressions/index). + pub args: Option>, /// - ⚡ `skipWhen`: an [expression](/expressions/index) that, when evaluated to false, will /// cause the command to *not* be run. - // **TODO**: implement `skipWhen` - pub args: Option>, + pub skipWhen: Option>>, } impl Expanding for CommandInput { @@ -69,6 +74,10 @@ impl Expanding for CommandInput { errors.append(&mut e.errors); None }), + skipWhen: self.skipWhen.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), }; if errors.len() > 0 { return Err(errors.into()); @@ -84,6 +93,7 @@ impl CommandInput { id: None, command: self.command.clone(), args: self.args.clone(), + skipWhen: self.skipWhen.clone(), }; } } @@ -111,6 +121,7 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec Value::Table(BTreeMap::new()), Some(spanned) => spanned.as_ref().clone(), }, + skipWhen: TypedValue::Constant(false), }]; return Ok(commands); } else { @@ -140,8 +151,12 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec (str.to_owned(), Value::Table(BTreeMap::new())), + let (command, args, skipWhen) = match command { + Value::String(str) => ( + str.to_owned(), + Value::Table(BTreeMap::new()), + TypedValue::default(), + ), Value::Table(kv) => { let result = kv.get("command").ok_or_else(|| { err("expected `args.commands.command` field for `runCommands`") @@ -153,9 +168,10 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec &Value::Table(BTreeMap::new()), + Some(x) => x, + }; let args = match result { x @ Value::Table(_) => x, x @ Value::Array(_) => x, @@ -163,7 +179,13 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec Value::Boolean(false), + Some(x) => x.clone(), + }; + let skipWhen: TypedValue = result.try_into()?; + (command_name, args.to_owned(), skipWhen) } _ => { return Err(err( @@ -171,7 +193,11 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec ResultVec, } #[wasm_bindgen] @@ -212,6 +239,89 @@ impl Command { Some(x) => x.into_inner(), None => Value::Table(BTreeMap::new()), }, + skipWhen: resolve!(input, skipWhen)?, }); } } + +#[cfg(test)] +mod tests { + use crate::bind::command::regularize_commands; + use test_log::test; + + use super::*; + + #[test] + fn parse_regularize_commands() { + let data = r#" + command = "runCommands" + + [[args.commands]] + command = "a" + + [[args.commands]] + command = "b" + args = { foo = 1, bar = 2 } + + [[args.commands]] + command = "c" + args = [1,2] + skipWhen = "{{count > 2}}" + "#; + + let bind = toml::from_str::(data).unwrap(); + let commands = regularize_commands(&bind).unwrap(); + + assert_eq!(commands[0].command, "a"); + assert_eq!(commands[1].command, "b"); + assert_eq!(commands[2].command, "c"); + + assert_eq!(commands[0].args, Value::Table(BTreeMap::new())); + assert_eq!( + commands[1].args, + Value::Table(BTreeMap::from([ + ("foo".to_string(), Value::Integer(1)), + ("bar".to_string(), Value::Integer(2)), + ])) + ); + assert_eq!( + commands[2].args, + Value::Array(vec![Value::Integer(1), Value::Integer(2)]) + ); + + assert_eq!(commands[0].skipWhen, TypedValue::Constant(false)); + assert_eq!(commands[1].skipWhen, TypedValue::Constant(false)); + assert_eq!( + commands[2].skipWhen, + TypedValue::Variable(Value::Expression("count > 2".to_string())) + ); + } + + #[test] + fn command_is_required() { + let data = r#" + command = "runCommands" + + [[args.commands]] + command = "a" + + [[args.commands]] + args = { foo = 1, bar = 2 } + "#; + + let bind = toml::from_str::(data).unwrap(); + let commands = regularize_commands(&bind).unwrap_err(); + let msg = match commands.errors[0].error { + crate::error::RawError::Static(x) => x, + _ => { + assert!(false); + "" + } + }; + + assert_eq!( + msg, + "expected `args.commands.command` field for `runCommands`" + ); + } +} diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 7b4a97d9..9ee4219d 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -451,11 +451,21 @@ where io::stdout().flush().unwrap(); let val: Value = value.try_into()?; + return Ok(val.try_into()?); + } +} + +impl<'e, T> TryFrom for TypedValue +where + T: Deserialize<'e> + Serialize + std::fmt::Debug, +{ + type Error = ErrorSet; + fn try_from(value: Value) -> ResultVec> { io::stdout().flush().unwrap(); - return match val.require_constant() { - Err(_) => Ok(TypedValue::Variable(val)), + return match value.require_constant() { + Err(_) => Ok(TypedValue::Variable(value)), Ok(_) => { - let toml: toml::Value = val.into(); + let toml: toml::Value = value.into(); let typed_value = toml.try_into(); Ok(TypedValue::Constant(typed_value?)) } From 170c0cd98b515dac74a5cfc74c598bf00cb38844 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 20 Sep 2025 17:24:30 -0400 Subject: [PATCH 53/79] cleanup compiler warnings Created using spr 1.3.6-beta.1 --- notes.md | 2 +- src/rust/parsing/src/bind.rs | 4 ++-- src/rust/parsing/src/bind/command.rs | 3 ++- src/rust/parsing/src/bind/validation.rs | 12 ++++++++---- src/rust/parsing/src/define.rs | 4 ++-- src/rust/parsing/src/expression.rs | 5 +++-- src/rust/parsing/src/expression/value.rs | 8 ++++---- src/rust/parsing/src/file.rs | 2 +- 8 files changed, 23 insertions(+), 17 deletions(-) diff --git a/notes.md b/notes.md index 9ba44ffa..64ceeffa 100644 --- a/notes.md +++ b/notes.md @@ -156,7 +156,7 @@ Integration test debugging: - [X] reduce types of errors and tie error message string more explicitly to name of enum variant - [X] get error reporting working in javascript again - - [ ] remove all compile warnings + - [X] remove all compile warnings - [X] implement support for tags on `bind` (for filter them) - [X] implement support for `skipWhen` in `command` - [ ] improve expression evaluation diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 08c6399c..049dc641 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -914,7 +914,7 @@ mod tests { args.value = "{{key}}" "#; - let mut result = toml::from_str::(data).unwrap(); + let result = toml::from_str::(data).unwrap(); let items = result.expand_foreach().unwrap(); let expected_name: Vec = @@ -947,7 +947,7 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - scope.parse_asts(&input); + scope.parse_asts(&input).unwrap(); let result = Binding::new(input).unwrap(); scope.state.set_or_push("joe", Dynamic::from("fiz")); let flat_args = result.commands[0].toml_args(&mut scope).unwrap(); diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 4299c12b..a8de6bc7 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -8,6 +8,7 @@ use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ bind::{BindingInput, UNKNOWN_RANGE}, + err, error::{ErrorContext, Result, ResultVec, err}, expression::Scope, expression::value::{Expanding, TypedValue, Value}, @@ -222,7 +223,7 @@ impl Command { pub fn args(&self, scope: &mut Scope) -> ResultVec { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); return match self.toml_args(scope)?.serialize(&to_json) { - Err(e) => Err(err("object failed to serialize: {e}"))?, + Err(e) => Err(err!("object failed to serialize: {e}"))?, Ok(x) => Ok(x), }; } diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 1a7051dc..11c6beab 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -5,8 +5,7 @@ use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; -use crate::err; -use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; +use crate::error::{ErrorSet, Result, ResultVec, err}; use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; use crate::util::{Merging, Resolving}; @@ -155,7 +154,7 @@ impl Expanding for KeyBinding { F: FnMut(String) -> Result, { Ok(match self { - KeyBinding(TypedValue::Constant(ref x)) => self, + KeyBinding(TypedValue::Constant(_)) => self, KeyBinding(TypedValue::Variable(value)) => match value.map_expressions(f)? { interp @ Value::Interp(_) => KeyBinding(TypedValue::Variable(interp)), exp @ Value::Expression(_) => KeyBinding(TypedValue::Variable(exp)), @@ -167,7 +166,12 @@ impl Expanding for KeyBinding { let mut result = String::new(); let toml: toml::Value = other.into(); let serializer = toml::ser::ValueSerializer::new(&mut result); - toml.serialize(serializer); + match toml.serialize(serializer) { + Ok(_) => (), + Err(_) => { + result.push_str(&format!("{toml:?}")); + } + }; return Err(err("expected a string, found `{result}`"))?; } }, diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 82aa1b42..48694895 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -309,9 +309,9 @@ impl Define { } mod tests { - // use test_log::test; - + #[allow(unused_imports)] use super::*; + #[test] fn simple_parsing() { let data = r#" diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index f65e0e21..88c9b993 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -141,7 +141,8 @@ impl Scope { #[wasm_bindgen(constructor)] pub fn new() -> Scope { let mut engine = rhai::Engine::new(); - engine.set_allow_looping(false).allow_statement_expression(); + engine.set_allow_looping(false); + engine.set_allow_statement_expression(false); return Scope { asts: HashMap::new(), @@ -175,7 +176,7 @@ impl Scope { .get(&name) .ok_or_else(|| err!("`{name}` is undefined"))?; let x: Value = match x.clone().try_cast_result() { - Err(e) => Err(err!("{x} is not a valid JSON value"))?, + Err(e) => Err(err!("{x} is not a valid JSON value: {e}"))?, Ok(x) => x, }; let x: toml::Value = x.into(); diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 9ee4219d..f2a4f5ba 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -402,7 +402,7 @@ impl Expanding for Required { impl Expanding for Option { fn is_constant(&self) -> bool { match self { - None => true, + Option::None => true, Some(x) => x.is_constant(), } } @@ -411,7 +411,7 @@ impl Expanding for Option { F: FnMut(String) -> Result, { return Ok(match self { - None => self, + Option::None => self, Some(x) => Some(x.map_expressions(f)?), }); } @@ -590,7 +590,7 @@ impl Resolving> for TypedValue where T: LeafValue + Serialize + std::fmt::Debug, { - fn resolve(self, name: &'static str) -> ResultVec> { + fn resolve(self, _name: &'static str) -> ResultVec> { return Ok(self); } } @@ -602,7 +602,7 @@ where fn resolve(self, _name: &'static str) -> ResultVec> { return match self { Some(x) => Ok(x.into_inner()), - None => Ok(TypedValue::default()), + Option::None => Ok(TypedValue::default()), }; } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 0f9330dd..f2c81b73 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -138,7 +138,7 @@ impl KeyFile { }; let mut scope = Scope::new(); - define.add_to_scope(&mut scope); + define.add_to_scope(&mut scope)?; let _ = scope .parse_asts(&bind_input) .map_err(|mut es| errors.append(&mut es.errors)); From 99910404c3d6bf4247cf94997e8decac36d04996 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 24 Sep 2025 15:28:49 -0400 Subject: [PATCH 54/79] better errors for expressions Created using spr 1.3.6-beta.1 --- errors.txt | 454 +----------------- notes.md | 52 ++- src/rust/parsing/Cargo.lock | 35 +- src/rust/parsing/Cargo.toml | 4 +- src/rust/parsing/errors.txt | 470 ++++++++----------- src/rust/parsing/src/bind.rs | 22 +- src/rust/parsing/src/bind/command.rs | 30 +- src/rust/parsing/src/bind/foreach.rs | 24 +- src/rust/parsing/src/bind/validation.rs | 12 +- src/rust/parsing/src/define.rs | 18 +- src/rust/parsing/src/error.rs | 125 ++--- src/rust/parsing/src/expression.rs | 136 ++++-- src/rust/parsing/src/expression/value.rs | 559 ++++++++++++++++++----- src/rust/parsing/src/file.rs | 29 +- src/rust/parsing/src/util.rs | 38 +- 15 files changed, 984 insertions(+), 1024 deletions(-) diff --git a/errors.txt b/errors.txt index 6dad41fc..dd7896c1 100644 --- a/errors.txt +++ b/errors.txt @@ -1,433 +1,25 @@ [test-rust] $ def main [...args] { Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) -warning: unused import: `RawError` - --> src/util.rs:9:41 - | -9 | use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, flatten_errors}; - | ^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default - -warning: unused import: `crate::err` - --> src/bind/validation.rs:8:5 - | -8 | use crate::err; - | ^^^^^^^^^^ - -warning: unused import: `RawError` - --> src/bind/validation.rs:9:30 - | -9 | use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; - | ^^^^^^^^ - -error[E0308]: mismatched types - --> src/bind.rs:755:61 - | -755 | assert_eq!(result.doc.unwrap().combinedDescription, "".to_string()); - | ^^^^^^^^^^^^^^ expected `Option>>`, found `String` - | - = note: expected enum `std::option::Option>>` - found struct `std::string::String` - -error[E0308]: mismatched types - --> src/bind.rs:756:54 - | -756 | assert_eq!(result.doc.unwrap().combinedName, "".to_string()); - | ^^^^^^^^^^^^^^ expected `Option>>`, found `String` - | - = note: expected enum `std::option::Option>>` - found struct `std::string::String` - -error[E0308]: mismatched types - --> src/util.rs:117:9 - | -117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option`, found `Result<_, ErrorSet>` - | - ::: src/bind.rs:797:26 - | -797 | let description: Option = resolve!(left.doc.unwrap(), combinedDescription); - | -------------- ------------------------------------------------ in this macro invocation - | | - | expected due to this - | - = note: expected enum `std::option::Option` - found enum `std::result::Result<_, ErrorSet>` - = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) -help: consider using `Result::expect` to unwrap the `std::result::Result<_, ErrorSet>` value, panicking if the value is a `Result::Err` - --> src/bind.rs:797:91 - | -797 | let description: Option = resolve!(left.doc.unwrap(), combinedDescription).expect("REASON"); - | +++++++++++++++++ - -error[E0308]: mismatched types - --> src/util.rs:117:9 - | -117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Option`, found `Result<_, ErrorSet>` - | - ::: src/bind.rs:799:19 - | -799 | let name: Option = resolve!(left.doc.unwrap(), combinedName); - | -------------- ----------------------------------------- in this macro invocation - | | - | expected due to this - | - = note: expected enum `std::option::Option` - found enum `std::result::Result<_, ErrorSet>` - = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) -help: consider using `Result::expect` to unwrap the `std::result::Result<_, ErrorSet>` value, panicking if the value is a `Result::Err` - --> src/bind.rs:799:77 - | -799 | let name: Option = resolve!(left.doc.unwrap(), combinedName).expect("REASON"); - | +++++++++++++++++ - -error[E0283]: type annotations needed - --> src/bind.rs:905:17 - | -905 | String::from(resolve!(item.doc.unwrap(), name).unwrap()), - | ^^^^^^ cannot infer type for type parameter `T` declared on the trait `From` - | -note: multiple `impl`s satisfying `std::string::String: From<_>` found - --> src/expression/value.rs:509:1 - | -509 | impl From> for String { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - ::: src/bind/validation.rs:178:1 - | -178 | impl From for String { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -... -260 | impl From for String { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - = note: and more `impl`s found in the following crates: `alloc`, `js_sys`, `rhai`, `smartstring`: - - impl From> for std::string::String; - - impl From for std::string::String; - - impl From for std::string::String; - - impl From for std::string::String; - - impl From for std::string::String; - - impl From for std::string::String; - -error[E0283]: type annotations needed - --> src/util.rs:117:9 - | -117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type - | - ::: src/bind.rs:905:30 - | -905 | String::from(resolve!(item.doc.unwrap(), name).unwrap()), - | --------------------------------- in this macro invocation - | -note: multiple `impl`s satisfying `std::option::Option>>: util::Resolving<_>` found - --> src/util.rs:155:1 - | -155 | / impl Resolving for Option -156 | | where -157 | | T: Resolving, -158 | | U: Default + LeafValue, - | |___________________________^ -... -168 | / impl Resolving> for Option -169 | | where -170 | | T: Resolving, - | |____________________^ - = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0283]: type annotations needed - --> src/util.rs:117:9 - | -117 | crate::util::Resolving::resolve(($x).$field, stringify!($field)) - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer type - | - ::: src/bind.rs:909:17 - | -909 | resolve!(item, args).unwrap(), - | -------------------- in this macro invocation - | -note: multiple `impl`s satisfying `std::option::Option>: util::Resolving<_>` found - --> src/util.rs:155:1 - | -155 | / impl Resolving for Option -156 | | where -157 | | T: Resolving, -158 | | U: Default + LeafValue, - | |___________________________^ -... -168 | / impl Resolving> for Option -169 | | where -170 | | T: Resolving, - | |____________________^ - = note: this error originates in the macro `resolve` (in Nightly builds, run with -Z macro-backtrace for more info) - -error[E0599]: no method named `unwrap` found for struct `bind::BindingInput` in the current scope - --> src/bind.rs:938:50 - | -65 | pub struct BindingInput { - | ----------------------- method `unwrap` not found for this struct -... -938 | let name: String = resolve!(items[i].unwrap(), name).unwrap(); - | ^^^^^^ method not found in `BindingInput` - | -help: some of the expressions' fields have a method of the same name - | -938 | let name: String = resolve!(items[i].args.unwrap(), name).unwrap(); - | +++++ -938 | let name: String = resolve!(items[i].default.unwrap(), name).unwrap(); - | ++++++++ -938 | let name: String = resolve!(items[i].doc.unwrap(), name).unwrap(); - | ++++ -938 | let name: String = resolve!(items[i].finalKey.unwrap(), name).unwrap(); - | +++++++++ - and 5 other candidates - -error[E0425]: cannot find function `parse_bytes` in this scope - --> src/file.rs:234:22 - | -234 | let result = parse_bytes(data); - | ^^^^^^^^^^^ not found in this scope - -error[E0609]: no field `name` on type `bind::Binding` - --> src/file.rs:269:35 - | -269 | assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); - | ^^^^ unknown field - | -help: one of the expressions' fields has a field of the same name - | -269 | assert_eq!(result.bind[0].doc.name.as_ref().unwrap(), "the whole shebang"); - | ++++ - -error[E0609]: no field `name` on type `bind::Binding` - --> src/file.rs:310:35 - | -310 | assert_eq!(result.bind[0].name.as_ref().unwrap(), "the whole shebang"); - | ^^^^ unknown field - | -help: one of the expressions' fields has a field of the same name - | -310 | assert_eq!(result.bind[0].doc.name.as_ref().unwrap(), "the whole shebang"); - | ++++ - -error[E0609]: no field `name` on type `bind::Binding` - --> src/file.rs:343:32 - | -343 | result.bind[i].name.as_ref().unwrap().clone(), - | ^^^^ unknown field - | -help: one of the expressions' fields has a field of the same name - | -343 | result.bind[i].doc.name.as_ref().unwrap().clone(), - | ++++ - -error[E0308]: mismatched types - --> src/file.rs:368:49 - | -368 | let report = result.unwrap_err().report(data); - | ------ ^^^^ expected `&[u8]`, found `&str` - | | - | arguments to this method are incorrect - | - = note: expected reference `&[u8]` - found reference `&str` -note: method defined here - --> src/error.rs:370:12 - | -370 | pub fn report(&self, content: &[u8]) -> Vec { - | ^^^^^^ -------------- - -error[E0609]: no field `items` on type `ErrorReport` - --> src/file.rs:370:23 - | -370 | report[0].items[0].message, - | ^^^^^ unknown field - | - = note: available fields are: `message`, `range` - -error[E0609]: no field `items` on type `ErrorReport` - --> src/file.rs:373:30 - | -373 | assert_eq!(report[0].items[1].range.as_ref().unwrap().start.line, 1); - | ^^^^^ unknown field - | - = note: available fields are: `message`, `range` - -error[E0609]: no field `items` on type `ErrorReport` - --> src/file.rs:374:30 - | -374 | assert_eq!(report[0].items[1].range.as_ref().unwrap().end.line, 1); - | ^^^^^ unknown field - | - = note: available fields are: `message`, `range` - -warning: unused variable: `e` - --> src/expression.rs:178:17 - | -178 | Err(e) => Err(err!("{x} is not a valid JSON value"))?, - | ^ help: if this is intentional, prefix it with an underscore: `_e` - | - = note: `#[warn(unused_variables)]` on by default - -warning: unused variable: `e` - --> src/bind/command.rs:198:17 - | -198 | Err(e) => Err(err("object failed to serialize: {e}"))?, - | ^ help: if this is intentional, prefix it with an underscore: `_e` - -warning: unused variable: `x` - --> src/bind/validation.rs:158:49 - | -158 | KeyBinding(TypedValue::Constant(ref x)) => self, - | ^ help: if this is intentional, prefix it with an underscore: `_x` - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:676:35 - | -673 | let name: String = resolve!(result.doc.unwrap(), name).unwrap(); - | ---------- -------- `result.doc` moved due to this method call - | | - | help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -... -676 | let description: String = result - | ___________________________________^ -677 | | .doc - | |________________^ value used here after move - | -note: `std::option::Option::::unwrap` takes ownership of the receiver `self`, which moves `result.doc` - --> /rustc/6b00bc3880198600130e1cf62b8f8a93494488cc/library/core/src/option.rs:1000:25 - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -673 | let name: String = resolve!(result.doc.clone().unwrap(), name).unwrap(); - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:684:32 - | -676 | let description: String = result - | ___________________________________- -677 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -678 | .unwrap() - | -------- `result.doc` moved due to this method call -... -684 | let hideInDocs: bool = result - | ________________________________^ -685 | | .doc - | |________________^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -677 | .doc.clone() - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:692:35 - | -684 | let hideInDocs: bool = result - | ________________________________- -685 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -686 | .unwrap() - | -------- `result.doc` moved due to this method call -... -692 | let hideInPalette: bool = result - | ___________________________________^ -693 | | .doc - | |________________^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -685 | .doc.clone() - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:700:36 - | -692 | let hideInPalette: bool = result - | ___________________________________- -693 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -694 | .unwrap() - | -------- `result.doc` moved due to this method call -... -700 | let combinedName: String = result - | ____________________________________^ -701 | | .doc - | |________________^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -693 | .doc.clone() - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:708:35 - | -700 | let combinedName: String = result - | ____________________________________- -701 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -702 | .unwrap() - | -------- `result.doc` moved due to this method call -... -708 | let combinedKey: String = result - | ___________________________________^ -709 | | .doc - | |________________^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -701 | .doc.clone() - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:716:43 - | -708 | let combinedKey: String = result - | ___________________________________- -709 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -710 | .unwrap() - | -------- `result.doc` moved due to this method call -... -716 | let combinedDescription: String = result - | ___________________________________________^ -717 | | .doc - | |________________^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -709 | .doc.clone() - | ++++++++ - -error[E0382]: use of moved value: `result.doc` - --> src/bind.rs:724:37 - | -716 | let combinedDescription: String = result - | ___________________________________________- -717 | | .doc - | |________________- help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents -718 | .unwrap() - | -------- `result.doc` moved due to this method call -... -724 | let kind: String = resolve!(result.doc.unwrap(), kind).unwrap(); - | ^^^^^^^^^^ value used here after move - | - = note: move occurs because `result.doc` has type `std::option::Option`, which does not implement the `Copy` trait -help: you can `clone` the value and consume it, but this might not be your desired behavior - | -717 | .doc.clone() - | ++++++++ - -Some errors have detailed explanations: E0283, E0308, E0382, E0425, E0599, E0609. -For more information about an error, try `rustc --explain E0283`. -warning: `parsing` (lib test) generated 6 warnings -error: could not compile `parsing` (lib test) due to 23 previous errors; 6 warnings emitted -[test-rust] ERROR task failed +warning: use of deprecated method `indexmap::IndexMap::::remove`: `remove` disrupts the map order -- use `swap_remove` or `shift_remove` for explicit behavior. + --> src/util.rs:66:66 + | +66 | let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { + | ^^^^^^ + | + = note: `#[warn(deprecated)]` on by default + +warning: variant `Datetime` is never constructed + --> src/expression/value.rs:35:5 + | +31 | enum RawValue { + | -------- variant in this enum +... +35 | Datetime(toml::value::Datetime), + | ^^^^^^^^ + | + = note: `RawValue` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis + = note: `#[warn(dead_code)]` on by default + +warning: `parsing` (lib test) generated 2 warnings + Finished `test` profile [unoptimized + debuginfo] target(s) in 1m 09s + Running unittests src/lib.rs (target/debug/deps/parsing-8866666de8fe2650) diff --git a/notes.md b/notes.md index 64ceeffa..258f93a4 100644 --- a/notes.md +++ b/notes.md @@ -130,7 +130,7 @@ Integration test debugging: - [X] define expansion for `bind.` and `command.` - [X] try it out from extension debugging - [X] write some type-script unit tests - - [ ] cleanup, document and refactor code + - [X] cleanup, document and refactor code - NOTE: we're waiting until we test out spans and the other stuff above because that could require more refactoring - [X] re-organize the code into smaller units - [X] bind is way to big start by breaking that up @@ -146,7 +146,7 @@ Integration test debugging: - [X] file - [X] lib - [X] util - - [X] replace IndexMap with BTreeMap + - [X] replace IndexMap with IndexMap - [X] update documentation of `bind`, `define` and `expressions` - [X] refactor plural to use `into` / `from` Vec - [X] update documentation rendering pipeline @@ -160,10 +160,34 @@ Integration test debugging: - [X] implement support for tags on `bind` (for filter them) - [X] implement support for `skipWhen` in `command` - [ ] improve expression evaluation + - [ ] improve error reporting in expressions + - [X] support spans for expressions + - [X] create a `RawValue` that tracks spans + - [X] try to implement with just the Span for expressions tracked + - [X] BUT this probably has to be for all variants, to avoid errors + - [X] parse as `RawValue` instead of `toml::Value` + - [X] inject Span into `Expression` + - NOTES: we can only include Span if the expression is a member of + a table not an array. We can handle this by using an optional + expression span. Error handling will then need to + generate a more disperse error around the span of the + array within its first containing map + - [X] datetimes are not explicitly handled in + `RawValue`: verify that we don't get an error parsing them + - [X] refactor / redocument `value.rs` + - [X] inject expression spans and rhai positions into error contexts + - [X] implementation + - [X] test that expressions spans properly resolve + - [ ] check for unmatched `{{` and `}}` in strings + - [X] implementation + - [~] test that unmatched mustaches raise an error + - need to defer these errors until we run parse_asts + so that we can get proper span information without + having to pass errors through a deserialization object - [ ] support expressions in `foreach` resolution - - [ ] check if each AST has a `foreach` variable and resolve it + - [ ] add foreach variables to a local scope object + - [ ] add this local scope when the expression is `resolve!`ed - [ ] allow for `var` evaluation in parse-time expressions - - [ ] move all bare variables in an expression to `key.` or `code.` object - [ ] implement support for `all` functions: - [ ] `{{all_prefixes()}}` - [ ] `{{all_modes()}}` @@ -186,16 +210,21 @@ Integration test debugging: - [ ] documentation expandsion/validation across all `[[bind]]` values with the same key and mode e.g. merge all shared documentation across the shared names + - [ ] find low hanging fruit for problems with using 1.0 files + - [ ] fields that exist in the old but not new (use #[serde(flatten)]) + - [ ] add hints for fields that don't exist anywhere as well (probably + as a hint or something) + - [ ] others - [ ] proper conversion to keybindings.json command - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause - [ ] re-implement master-key.do - - [ ] fix and test command queues implementation (avoid copying) + - [ ] move all bare variables in an expression to `key.` or `code.` object + - [ ] transfer scope state from TS to rust Scope object + - [ ] properly handle command queues (no controlled by rust) - [ ] guess: don't have special command queue field - [ ] support accessing values by their path (`val.foo`, `key.count`) from javascript - - [ ] transfer scope state from TS to rust Scope object - - [ ] properly handle command queues (no controlled by rust) - [ ] unit tests - [ ] integration tests - [ ] implement `replay`: use the new rust command queues instead of the old @@ -212,15 +241,6 @@ Integration test debugging: - [ ] test this on the old version of larkin.toml - [ ] actually replace javascript behavior with rust functions (replace `dod`) - [ ] replace `setFlag` with `updateDefine` (or something like that) - - [ ] improve error reporting in expressions - - [ ] support spans for expressions - - [ ] create a `SpannedValue` that tracks spans - - [ ] try to implement with just the Span for expressions tracked - - [ ] BUT this probably has to be for all variants, to avoid errors - - [ ] parse as `SpannedValue` instead of `toml::Value` - - [ ] inject Span into `Expression` - - [ ] inject expression spans and rhai positions into error contexts - - [ ] test that expressions spans properly resolve - [ ] CI - [x] setup CI unit tests for rust - [x] setup rust coverage diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index d7a61036..5d00bb1e 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -360,11 +360,13 @@ dependencies = [ "rhai", "serde", "serde-wasm-bindgen", + "serde_spanned", "smallvec", "string-offsets", "test-log", "thiserror", "toml", + "toml_datetime", "wasm-bindgen", "wasm-bindgen-test", ] @@ -504,10 +506,11 @@ dependencies = [ [[package]] name = "serde" -version = "1.0.219" +version = "1.0.226" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6" +checksum = "0dca6411025b24b60bfa7ec1fe1f8e710ac09782dca409ee8237ba74b51295fd" dependencies = [ + "serde_core", "serde_derive", ] @@ -522,11 +525,20 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "serde_core" +version = "1.0.226" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba2ba63999edb9dac981fb34b3e5c0d111a69b0924e253ed29d83f7c99e966a4" +dependencies = [ + "serde_derive", +] + [[package]] name = "serde_derive" -version = "1.0.219" +version = "1.0.226" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" +checksum = "8db53ae22f34573731bafa1db20f04027b2d25e02d8205921b569171699cdb33" dependencies = [ "proc-macro2", "quote", @@ -535,11 +547,11 @@ dependencies = [ [[package]] name = "serde_spanned" -version = "1.0.0" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40734c41988f7306bb04f0ecf60ec0f3f1caa34290e4e8ea471dcd3346483b83" +checksum = "5417783452c2be558477e104686f7de5dae53dba813c28435e0e70f82d9b04ee" dependencies = [ - "serde", + "serde_core", ] [[package]] @@ -562,6 +574,9 @@ name = "smallvec" version = "1.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" +dependencies = [ + "serde", +] [[package]] name = "smartstring" @@ -683,11 +698,11 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "0.7.0" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bade1c3e902f58d73d3f294cd7f20391c1cb2fbcb643b73566bc773971df91e3" +checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1" dependencies = [ - "serde", + "serde_core", ] [[package]] diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 259ccf4d..6aab0137 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -27,7 +27,9 @@ toml = { version = "0.9.2", features = ["preserve_order"] } wasm-bindgen = "0.2.100" wasm-bindgen-test = "0.3.50" instant = { version = "0.1.13", features = ["wasm-bindgen"] } -smallvec = "1.15.1" +smallvec = { version = "1.15.1", features = ["serde"] } +serde_spanned = "1.0.2" +toml_datetime = "0.7.2" [lib] crate-type = ["cdylib"] diff --git a/src/rust/parsing/errors.txt b/src/rust/parsing/errors.txt index d91d5e2c..57829db5 100644 --- a/src/rust/parsing/errors.txt +++ b/src/rust/parsing/errors.txt @@ -1,200 +1,115 @@ [test-rust] $ def main [...args] { Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) -warning: unused import: `RawError` - --> src/util.rs:9:41 - | -9 | use crate::error::{Error, ErrorContext, RawError, Result, ResultVec, flatten_errors}; - | ^^^^^^^^ - | - = note: `#[warn(unused_imports)]` on by default + Finished `test` profile [unoptimized + debuginfo] target(s) in 26.36s + Running unittests src/lib.rs (target/debug/deps/parsing-4b199d9df4c1bd45) -warning: unused import: `crate::err` - --> src/bind/validation.rs:8:5 - | -8 | use crate::err; - | ^^^^^^^^^^ - -warning: unused import: `RawError` - --> src/bind/validation.rs:9:30 - | -9 | use crate::error::{ErrorSet, RawError, Result, ResultVec, err}; - | ^^^^^^^^ - -warning: unused variable: `e` - --> src/expression.rs:178:17 - | -178 | Err(e) => Err(err!("{x} is not a valid JSON value"))?, - | ^ help: if this is intentional, prefix it with an underscore: `_e` - | - = note: `#[warn(unused_variables)]` on by default - -warning: unused variable: `e` - --> src/bind/command.rs:198:17 - | -198 | Err(e) => Err(err("object failed to serialize: {e}"))?, - | ^ help: if this is intentional, prefix it with an underscore: `_e` - -warning: unused variable: `x` - --> src/bind/validation.rs:158:49 - | -158 | KeyBinding(TypedValue::Constant(ref x)) => self, - | ^ help: if this is intentional, prefix it with an underscore: `_x` - -warning: variable does not need to be mutable - --> src/bind.rs:869:13 - | -869 | let mut result = toml::from_str::(data).unwrap(); - | ----^^^^^^ - | | - | help: remove this `mut` - | - = note: `#[warn(unused_mut)]` on by default - -warning: variable does not need to be mutable - --> src/bind.rs:904:13 - | -904 | let mut result = toml::from_str::(data).unwrap(); - | ----^^^^^^ - | | - | help: remove this `mut` - -warning: methods `with_expression_range` and `with_pos` are never used - --> src/error.rs:107:8 - | -90 | pub trait ErrorContext - | ------------ methods in this trait -... -107 | fn with_expression_range( - | ^^^^^^^^^^^^^^^^^^^^^ -... -117 | fn with_pos(self, context: rhai::Position) -> std::result::Result { - | ^^^^^^^^ - | - = note: `#[warn(dead_code)]` on by default - -warning: unused return value of `rhai::api::options::::allow_statement_expression` that must be used - --> src/expression.rs:144:9 - | -144 | engine.set_allow_looping(false).allow_statement_expression(); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: `#[warn(unused_must_use)]` on by default -help: use `let _ = ...` to ignore the resulting value - | -144 | let _ = engine.set_allow_looping(false).allow_statement_expression(); - | +++++++ - -warning: unused `std::result::Result` that must be used - --> src/bind/validation.rs:170:21 - | -170 | toml.serialize(serializer); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this `Result` may be an `Err` variant, which should be handled -help: use `let _ = ...` to ignore the resulting value - | -170 | let _ = toml.serialize(serializer); - | +++++++ - -warning: unused `std::result::Result` that must be used - --> src/bind.rs:937:9 - | -937 | scope.parse_asts(&input); - | ^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this `Result` may be an `Err` variant, which should be handled -help: use `let _ = ...` to ignore the resulting value - | -937 | let _ = scope.parse_asts(&input); - | +++++++ - -warning: unused `std::result::Result` that must be used - --> src/file.rs:138:9 - | -138 | define.add_to_scope(&mut scope); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - | - = note: this `Result` may be an `Err` variant, which should be handled -help: use `let _ = ...` to ignore the resulting value - | -138 | let _ = define.add_to_scope(&mut scope); - | +++++++ - -warning: `parsing` (lib test) generated 13 warnings (run `cargo fix --lib -p parsing --tests` to apply 5 suggestions) - Finished `test` profile [unoptimized + debuginfo] target(s) in 2.90s - Running unittests src/lib.rs (target/debug/deps/parsing-8ee028e04a7e2ca2) - -thread 'bind::tests::expands_foreach' panicked at src/bind.rs:881:50: -called `Option::unwrap()` on a `None` value +thread 'bind::tests::complete_parsing' panicked at src/bind.rs:644:59: +called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `do`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"do\"\n args = { a = \"2\", b = 3 }\n key = \"a\"\n when = \"joe > 1\"\n mode = \"normal\"\n priority = 1\n default = \"{{bind.foo_bar}}\"\n foreach.index = [1,2,3]\n prefixes = \"c\"\n finalKey = true\n repeat = \"{{2+c}}\"\n tags = [\"foo\", \"bar\"]\n doc.name = \"foo\"\n doc.description = \"foo bar bin\"\n doc.hideInPalette = false\n doc.hideInDocs = false\n doc.combinedName = \"Up/down\"\n doc.combinedKey = \"A/B\"\n doc.combinedDescription = \"bla bla bla\"\n doc.kind = \"biz\"\n "), keys: ["command"], span: Some(19..23) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::panic - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 - 3: core::option::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 - 4: core::option::Option::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 - 5: parsing::bind::tests::expands_foreach - at ./src/bind.rs:881:50 - 6: parsing::bind::tests::expands_foreach::{{closure}} - at ./src/bind.rs:860:25 - 7: core::ops::function::FnOnce::call_once + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::complete_parsing + at ./src/bind.rs:644:59 + 5: parsing::bind::tests::complete_parsing::{{closure}} + at ./src/bind.rs:620:26 + 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 8: core::ops::function::FnOnce::call_once + 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::expand_foreach_keys' panicked at src/bind.rs:913:62: -called `Option::unwrap()` on a `None` value +thread 'bind::command::tests::command_is_required' panicked at src/bind/command.rs:319:57: +called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"runCommands\"\n\n [[args.commands]]\n command = \"a\"\n\n [[args.commands]]\n args = { foo = 1, bar = 2 }\n "), keys: ["command"], span: Some(19..32) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::panic - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 - 3: core::option::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 - 4: core::option::Option::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 - 5: parsing::bind::tests::expand_foreach_keys - at ./src/bind.rs:913:62 - 6: parsing::bind::tests::expand_foreach_keys::{{closure}} - at ./src/bind.rs:894:29 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::command::tests::command_is_required + at ./src/bind/command.rs:319:57 + 5: parsing::bind::command::tests::command_is_required::{{closure}} + at ./src/bind/command.rs:308:29 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 8: core::ops::function::FnOnce::call_once +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::command::tests::parse_regularize_commands' panicked at src/bind/command.rs:275:57: +called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"runCommands\"\n\n [[args.commands]]\n command = \"a\"\n\n [[args.commands]]\n command = \"b\"\n args = { foo = 1, bar = 2 }\n\n [[args.commands]]\n command = \"c\"\n args = [1,2]\n skipWhen = \"{{count > 2}}\"\n "), keys: ["command"], span: Some(19..32) } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::command::tests::parse_regularize_commands + at ./src/bind/command.rs:275:57 + 5: parsing::bind::command::tests::parse_regularize_commands::{{closure}} + at ./src/bind/command.rs:258:35 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::simple_command_merging' panicked at src/bind.rs:773:28: -called `Option::unwrap()` on a `None` value +thread 'bind::tests::merge_nested_arguments' panicked at src/bind.rs:814:81: +called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `default`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n [[bind]]\n doc.name = \"default\"\n command = \"cursorMove\"\n args.foo = { a = 2, b = 3, c = { x = 1 } }\n\n [[bind]]\n key = \"r\"\n doc.name = \"→\"\n args.foo = { d = 12, c = { y = 2 } }\n\n [[bind]]\n key = \"x\"\n doc.name = \"expected\"\n args.foo = { a = 2, b = 3, c = { x = 1, y = 2 }, d = 12 }\n "), keys: ["bind", "doc", "name"], span: Some(45..54) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::panic - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 - 3: core::option::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 - 4: core::option::Option::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 - 5: parsing::bind::tests::simple_command_merging - at ./src/bind.rs:773:28 - 6: parsing::bind::tests::simple_command_merging::{{closure}} - at ./src/bind.rs:736:32 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::merge_nested_arguments + at ./src/bind.rs:814:81 + 5: parsing::bind::tests::merge_nested_arguments::{{closure}} + at ./src/bind.rs:796:32 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 8: core::ops::function::FnOnce::call_once +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'define::tests::simple_parsing' panicked at src/define.rs:337:70: +called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `bill`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[val]]\n y = \"bill\"\n\n [[bind]]\n id = \"foo\"\n key = \"x\"\n command = \"foo\"\n args = { k = 1, h = 2 }\n\n [[command]]\n id = \"foobar\"\n command = \"runCommands\"\n args.commands = [\"foo\", \"bar\"]\n\n [[val]]\n joe = \"bob\"\n\n "), keys: ["val", "y"], span: Some(29..35) } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::define::tests::simple_parsing + at ./src/define.rs:337:70 + 5: parsing::define::tests::simple_parsing::{{closure}} + at ./src/define.rs:316:24 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::complete_parsing' panicked at src/bind.rs:629:59: -called `Result::unwrap()` on an `Err` value: Error { message: "invalid type: string \"normal\", expected a sequence", input: Some("\n command = \"do\"\n args = { a = \"2\", b = 3 }\n key = \"a\"\n when = \"joe > 1\"\n mode = \"normal\"\n priority = 1\n default = \"{{bind.foo_bar}}\"\n foreach.index = [1,2,3]\n prefixes = \"c\"\n finalKey = true\n repeat = \"{{2+c}}\"\n name = \"foo\"\n description = \"foo bar bin\"\n hideInPalette = false\n hideInDocs = false\n combinedName = \"Up/down\"\n combinedKey = \"A/B\"\n combinedDescription = \"bla bla bla\"\n kind = \"biz\"\n "), keys: ["mode"], span: Some(116..124) } +thread 'bind::tests::expand_foreach_keys' panicked at src/bind.rs:917:59: +called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["foreach", "key"], span: Some(28..47) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 @@ -204,85 +119,102 @@ stack backtrace: at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 3: core::result::Result::unwrap at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::complete_parsing - at ./src/bind.rs:629:59 - 5: parsing::bind::tests::complete_parsing::{{closure}} - at ./src/bind.rs:606:26 + 4: parsing::bind::tests::expand_foreach_keys + at ./src/bind.rs:917:59 + 5: parsing::bind::tests::expand_foreach_keys::{{closure}} + at ./src/bind.rs:909:29 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::default_parsing' panicked at src/bind.rs:726:30: -called `Option::unwrap()` on a `None` value +thread 'bind::tests::default_parsing' panicked at src/bind.rs:727:59: +called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `cursorMove`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n key = \"l\"\n command = \"cursorMove\"\n args.to = \"left\"\n "), keys: ["command"], span: Some(37..49) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::panic - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:145:5 - 3: core::option::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:2072:5 - 4: core::option::Option::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/option.rs:1005:21 - 5: parsing::bind::tests::default_parsing - at ./src/bind.rs:726:30 - 6: parsing::bind::tests::default_parsing::{{closure}} - at ./src/bind.rs:702:25 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::default_parsing + at ./src/bind.rs:727:59 + 5: parsing::bind::tests::default_parsing::{{closure}} + at ./src/bind.rs:720:25 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 8: core::ops::function::FnOnce::call_once +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'file::tests::resolve_bind_and_command' panicked at src/file.rs:272:72: +called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `bizbaz`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n\n [[define.val]]\n foo_string = \"bizbaz\"\n\n [[define.command]]\n id = \"run_shebang\"\n command = \"shebang\"\n args.a = 1\n args.b = \"{{val.foo_string}}\"\n\n [[define.bind]]\n id = \"whole_shebang\"\n doc.name = \"the whole shebang\"\n command = \"runCommands\"\n args.commands = [\"{{command.run_shebang}}\", \"bar\"]\n\n [[bind]]\n default = \"{{bind.whole_shebang}}\"\n key = \"a\"\n "), keys: ["define", "val", "foo_string"], span: Some(46..54) } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::file::tests::resolve_bind_and_command + at ./src/file.rs:272:72 + 5: parsing::file::tests::resolve_bind_and_command::{{closure}} + at ./src/file.rs:249:34 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::merge_nested_arguments' panicked at src/bind.rs:805:9: -assertion `left == right` failed - left: Some(Spanned { span: 98..102, value: Table({"foo": Table({"a": Integer(2), "b": Integer(3), "c": Table({"x": Integer(1)})})}) }) - right: Some(Spanned { span: 345..349, value: Table({"foo": Table({"a": Integer(2), "b": Integer(3), "c": Table({"x": Integer(1), "y": Integer(2)}), "d": Integer(12)})}) }) +thread 'bind::tests::simple_command_merging' panicked at src/bind.rs:765:81: +called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `default`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n [[bind]]\n doc.name = \"default\"\n command = \"cursorMove\"\n prefixes = [\"a\"]\n\n [[bind]]\n key = \"l\"\n doc.name = \"←\"\n args.to = \"left\"\n prefixes = [\"b\", \"c\"]\n "), keys: ["bind", "doc", "name"], span: Some(37..46) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::assert_failed_inner - 3: core::panicking::assert_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 - 4: parsing::bind::tests::merge_nested_arguments - at ./src/bind.rs:805:9 - 5: parsing::bind::tests::merge_nested_arguments::{{closure}} - at ./src/bind.rs:781:32 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::simple_command_merging + at ./src/bind.rs:765:81 + 5: parsing::bind::tests::simple_command_merging::{{closure}} + at ./src/bind.rs:751:32 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'bind::tests::merge_nested_array_arguments' panicked at src/bind.rs:856:9: -assertion `left == right` failed - left: Some(Spanned { span: 107..111, value: Table({"commands": Array([Table({"args": Table({"b": String("bar")}), "command": String("step1")}), Table({"args": Table({"x": String("biz")}), "command": String("step2")})])}) }) - right: Some(Spanned { span: 696..700, value: Table({"commands": Array([Table({"args": Table({"a": String("foo"), "b": String("bar")}), "command": String("step1")}), Table({"args": Table({"x": String("biz"), "y": String("fiz")}), "command": String("step2")})])}) }) +thread 'bind::tests::merge_nested_array_arguments' panicked at src/bind.rs:865:81: +called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n [[bind]]\n name = \"default\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args.b = \"bar\"\n\n [[bind.args.commands]]\n command = \"step2\"\n args.x = \"biz\"\n\n [[bind]]\n name = \"run\"\n key = \"x\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args.a = \"foo\"\n\n [[bind.args.commands]]\n command = \"step2\"\n args.y = \"fiz\"\n\n [[bind]]\n name = \"run_merged\"\n key = \"x\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args = {a = \"foo\", b = \"bar\"}\n\n [[bind.args.commands]]\n command = \"step2\"\n args = {x = \"biz\", y = \"fiz\"}\n "), keys: ["bind", "command"], span: Some(73..86) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::assert_failed_inner - 3: core::panicking::assert_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 4: parsing::bind::tests::merge_nested_array_arguments - at ./src/bind.rs:856:9 + at ./src/bind.rs:865:81 5: parsing::bind::tests::merge_nested_array_arguments::{{closure}} - at ./src/bind.rs:809:38 + at ./src/bind.rs:824:38 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'file::tests::parse_example' panicked at src/file.rs:234:58: -called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: TomlParsing(Error { message: "invalid type: string \"normal\", expected a sequence", input: Some("\n [[define.var]]\n foo = \"bar\"\n\n [[bind]]\n key = \"l\"\n mode = \"normal\"\n command = \"cursorRight\"\n\n [[bind]]\n key = \"h\"\n model = \"normal\"\n command = \"cursorLeft\"\n "), keys: ["bind", "mode"], span: Some(95..103) }), contexts: [] }] } +thread 'file::tests::resolve_nested_command' panicked at src/file.rs:320:72: +called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `run_shebang`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n\n [[define.command]]\n id = \"run_shebang\"\n command = \"shebang\"\n args.a = 1\n args.b = \"{{val.foo_string}}\"\n\n [[define.bind]]\n id = \"a\"\n args.commands = [\"{{command.run_shebang}}\", \"bar\"]\n\n [[define.bind]]\n id = \"b\"\n key = \"x\"\n command = \"runCommands\"\n default = \"{{bind.a}}\"\n\n [[bind]]\n default = \"{{bind.b}}\"\n doc.name = \"the whole shebang\"\n key = \"a\"\n "), keys: ["define", "command", "id"], span: Some(42..55) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 @@ -292,69 +224,39 @@ stack backtrace: at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 3: core::result::Result::unwrap at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::parse_example - at ./src/file.rs:234:58 - 5: parsing::file::tests::parse_example::{{closure}} - at ./src/file.rs:218:23 + 4: parsing::file::tests::resolve_nested_command + at ./src/file.rs:320:72 + 5: parsing::file::tests::resolve_nested_command::{{closure}} + at ./src/file.rs:295:32 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'file::tests::foreach_error' panicked at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:291:32: -attempt to add with overflow +thread 'file::tests::expand_foreach' panicked at src/file.rs:353:72: +called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[bind]]\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n key = \"c {{key}}\"\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["bind", "foreach", "key"], span: Some(41..60) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::panic_const::panic_const_add_overflow - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:175:17 - 3: string_offsets::StringOffsets::utf8_to_char - at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:291:32 - 4: string_offsets::StringOffsets::utf8_to_char_pos - at /Users/davidlittle/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/string-offsets-0.2.0/src/lib.rs:264:29 - 5: parsing::error::range_to_pos - at ./src/error.rs:277:23 - 6: parsing::error::Error::report - at ./src/error.rs:327:41 - 7: parsing::error::ErrorSet::report::{{closure}} - at ./src/error.rs:371:45 - 8: core::iter::adapters::map::map_fold::{{closure}} - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/adapters/map.rs:88:28 - 9: as core::iter::traits::iterator::Iterator>::fold - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/slice/iter/macros.rs:255:27 - 10: as core::iter::traits::iterator::Iterator>::fold - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/adapters/map.rs:128:19 - 11: core::iter::traits::iterator::Iterator::for_each - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/traits/iterator.rs:827:14 - 12: alloc::vec::Vec::extend_trusted - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/mod.rs:3611:26 - 13: as alloc::vec::spec_extend::SpecExtend>::spec_extend - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_extend.rs:29:14 - 14: as alloc::vec::spec_from_iter_nested::SpecFromIterNested>::from_iter - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_from_iter_nested.rs:62:16 - 15: as alloc::vec::spec_from_iter::SpecFromIter>::from_iter - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/spec_from_iter.rs:34:9 - 16: as core::iter::traits::collect::FromIterator>::from_iter - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/alloc/src/vec/mod.rs:3470:9 - 17: core::iter::traits::iterator::Iterator::collect - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/iter/traits/iterator.rs:2027:9 - 18: parsing::error::ErrorSet::report - at ./src/error.rs:371:62 - 19: parsing::file::tests::foreach_error - at ./src/file.rs:364:42 - 20: parsing::file::tests::foreach_error::{{closure}} - at ./src/file.rs:353:23 - 21: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 22: core::ops::function::FnOnce::call_once + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::file::tests::expand_foreach + at ./src/file.rs:353:72 + 5: parsing::file::tests::expand_foreach::{{closure}} + at ./src/file.rs:343:24 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'file::tests::resolve_nested_command' panicked at src/file.rs:307:82: -called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: ExpressionParsing(ParseError(Reserved("var"), 1:1)), contexts: [Range(191..195), Range(374..382)] }] } +thread 'file::tests::foreach_error' panicked at src/file.rs:383:72: +called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[bind]]\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["bind", "foreach", "key"], span: Some(41..60) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 @@ -364,18 +266,18 @@ stack backtrace: at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 3: core::result::Result::unwrap at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::resolve_nested_command - at ./src/file.rs:307:82 - 5: parsing::file::tests::resolve_nested_command::{{closure}} - at ./src/file.rs:282:32 + 4: parsing::file::tests::foreach_error + at ./src/file.rs:383:72 + 5: parsing::file::tests::foreach_error::{{closure}} + at ./src/file.rs:373:23 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'file::tests::resolve_bind_and_command' panicked at src/file.rs:266:82: -called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: ExpressionParsing(ParseError(Reserved("var"), 1:1)), contexts: [Range(324..328), Range(384..392)] }] } +thread 'file::tests::parse_example' panicked at src/file.rs:240:58: +called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: TomlParsing(Error { message: "unknown variant `bar`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[define.val]]\n foo = \"bar\"\n\n [[bind]]\n key = \"l\"\n mode = \"normal\"\n command = \"cursorRight\"\n\n [[bind]]\n key = \"h\"\n model = \"normal\"\n command = \"cursorLeft\"\n "), keys: ["define", "val", "foo"], span: Some(38..43) }), contexts: [] }] } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 @@ -385,32 +287,52 @@ stack backtrace: at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 3: core::result::Result::unwrap at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::resolve_bind_and_command - at ./src/file.rs:266:82 - 5: parsing::file::tests::resolve_bind_and_command::{{closure}} - at ./src/file.rs:243:34 + 4: parsing::file::tests::parse_example + at ./src/file.rs:240:58 + 5: parsing::file::tests::parse_example::{{closure}} + at ./src/file.rs:224:23 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -thread 'file::tests::expand_foreach' panicked at src/file.rs:341:13: -assertion `left == right` failed - left: "" - right: "update 0" +thread 'bind::tests::expands_foreach' panicked at src/bind.rs:884:59: +called `Result::unwrap()` on an `Err` value: Error { message: "wanted string or table", input: Some("\n foreach.a = [1, 2]\n foreach.b = [\"x\", \"y\"]\n doc.name = \"test {{a}}-{{b}}\"\n command = \"run-{{a}}\"\n args.value = \"with-{{b}}\"\n "), keys: ["foreach", "a"], span: Some(26..27) } stack backtrace: 0: __rustc::rust_begin_unwind at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 1: core::panicking::panic_fmt at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::panicking::assert_failed_inner - 3: core::panicking::assert_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:387:5 - 4: parsing::file::tests::expand_foreach - at ./src/file.rs:341:13 - 5: parsing::file::tests::expand_foreach::{{closure}} - at ./src/file.rs:323:24 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::expands_foreach + at ./src/bind.rs:884:59 + 5: parsing::bind::tests::expands_foreach::{{closure}} + at ./src/bind.rs:875:25 + 6: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 + 7: core::ops::function::FnOnce::call_once + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 +note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. + +thread 'bind::tests::expand_args' panicked at src/bind.rs:948:58: +called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `test`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n key = \"k\"\n doc.name = \"test\"\n command = \"foo\"\n args.value = '{{joe + \"_biz\"}}'\n args.number = '{{2+1}}'\n "), keys: ["doc", "name"], span: Some(46..52) } +stack backtrace: + 0: __rustc::rust_begin_unwind + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 + 1: core::panicking::panic_fmt + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 + 2: core::result::unwrap_failed + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 + 3: core::result::Result::unwrap + at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 + 4: parsing::bind::tests::expand_args + at ./src/bind.rs:948:58 + 5: parsing::bind::tests::expand_args::{{closure}} + at ./src/bind.rs:939:21 6: core::ops::function::FnOnce::call_once at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 7: core::ops::function::FnOnce::call_once diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 049dc641..65a0084c 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -3,8 +3,8 @@ #[allow(unused_imports)] use log::info; +use indexmap::IndexMap; use serde::{Deserialize, Serialize}; -use std::collections::BTreeMap; use std::convert::identity; use toml::Spanned; use wasm_bindgen::prelude::*; @@ -17,7 +17,7 @@ use crate::bind::command::{Command, regularize_commands}; use crate::bind::validation::{BindingReference, KeyBinding}; use crate::error::{Result, ResultVec, err}; use crate::expression::Scope; -use crate::expression::value::{Expanding, TypedValue, Value}; +use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; use crate::util::{Merging, Plural, Required, Resolving}; @@ -126,7 +126,7 @@ pub struct BindingInput { /// - `foreach`: Allows parametric definition of multiple keybindings, see /// [`foreach` clauses](#foreach-clauses). #[serde(default)] - pub foreach: Option>>>, + pub foreach: Option>>>, /// @forBindingField bind /// @@ -289,7 +289,7 @@ impl Expanding for BindingInput { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { let mut errors = Vec::new(); let result = BindingInput { @@ -455,7 +455,7 @@ impl Expanding for BindingDocInput { fn map_expressions(self, f: &mut F) -> ResultVec where Self: Sized, - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { let mut errors = Vec::new(); let result = BindingDocInput { @@ -651,7 +651,7 @@ mod tests { let args = result.args.unwrap().into_inner(); assert_eq!( args, - Value::Table(BTreeMap::from([ + Value::Table(HashMap::from([ ("a".into(), Value::String("2".into())), ("b".into(), Value::Integer(3)) ])) @@ -735,10 +735,7 @@ mod tests { ); assert_eq!( result.args.unwrap().into_inner(), - Value::Table(BTreeMap::from([( - "to".into(), - Value::String("left".into()) - )])) + Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); let modes: Vec = resolve!(result, mode).unwrap(); @@ -776,10 +773,7 @@ mod tests { assert_eq!( left.args.unwrap().into_inner(), - Value::Table(BTreeMap::from([( - "to".into(), - Value::String("left".into()) - )])) + Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); let prefixes: Vec = resolve!(left, prefixes).unwrap(); diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index a8de6bc7..c3664c0a 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -2,7 +2,7 @@ use log::info; use serde::{Deserialize, Serialize}; -use std::collections::BTreeMap; +use std::collections::HashMap; use toml::Spanned; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; @@ -10,8 +10,10 @@ use crate::{ bind::{BindingInput, UNKNOWN_RANGE}, err, error::{ErrorContext, Result, ResultVec, err}, - expression::Scope, - expression::value::{Expanding, TypedValue, Value}, + expression::{ + Scope, + value::{Expanding, Expression, TypedValue, Value}, + }, resolve, util::{Required, Resolving}, }; @@ -62,7 +64,7 @@ impl Expanding for CommandInput { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { let mut errors = Vec::new(); let result = CommandInput { @@ -101,7 +103,7 @@ impl CommandInput { impl From for Value { fn from(value: CommandInput) -> Self { - let mut entries = BTreeMap::new(); + let mut entries = HashMap::new(); let command = value.command.into_inner(); if let Required::Value(command_value) = command { entries.insert("command".to_string(), command_value.into()); @@ -119,7 +121,7 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec Value::Table(BTreeMap::new()), + None => Value::Table(HashMap::new()), Some(spanned) => spanned.as_ref().clone(), }, skipWhen: TypedValue::Constant(false), @@ -155,7 +157,7 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec ( str.to_owned(), - Value::Table(BTreeMap::new()), + Value::Table(HashMap::new()), TypedValue::default(), ), Value::Table(kv) => { @@ -170,7 +172,7 @@ pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec &Value::Table(BTreeMap::new()), + None => &Value::Table(HashMap::new()), Some(x) => x, }; let args = match result { @@ -238,7 +240,7 @@ impl Command { command: resolve!(input, command)?, args: match input.args { Some(x) => x.into_inner(), - None => Value::Table(BTreeMap::new()), + None => Value::Table(HashMap::new()), }, skipWhen: resolve!(input, skipWhen)?, }); @@ -277,10 +279,10 @@ mod tests { assert_eq!(commands[1].command, "b"); assert_eq!(commands[2].command, "c"); - assert_eq!(commands[0].args, Value::Table(BTreeMap::new())); + assert_eq!(commands[0].args, Value::Table(HashMap::new())); assert_eq!( commands[1].args, - Value::Table(BTreeMap::from([ + Value::Table(HashMap::from([ ("foo".to_string(), Value::Integer(1)), ("bar".to_string(), Value::Integer(2)), ])) @@ -294,7 +296,11 @@ mod tests { assert_eq!(commands[1].skipWhen, TypedValue::Constant(false)); assert_eq!( commands[2].skipWhen, - TypedValue::Variable(Value::Expression("count > 2".to_string())) + TypedValue::Variable(Value::Exp(Expression { + content: "count > 2".to_string(), + span: UNKNOWN_RANGE, + scope: smallvec::SmallVec::new(), + })) ); } diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 02c0ee58..37948a4e 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -39,11 +39,11 @@ use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use std::collections::BTreeMap; +use indexmap::IndexMap; use toml::Spanned; use crate::error::{ErrorContext, Result, ResultVec}; -use crate::expression::value::{Expanding, Value}; +use crate::expression::value::{Expanding, Expression, Value}; const ALL_KEYS: [&'static str; 192] = [ "f0", @@ -245,8 +245,8 @@ lazy_static! { // static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); } -fn expand_keys_str(val: String) -> Result { - let c = KEY_PATTERN_REGEX.captures(&val); +fn expand_keys_str(val: Expression) -> Result { + let c = KEY_PATTERN_REGEX.captures(&val.content); if let Some(caps) = c { let key_regex = Regex::new(&caps[1])?; let mut result = Vec::new(); @@ -257,13 +257,13 @@ fn expand_keys_str(val: String) -> Result { } return Ok(Value::Array(result)); } else { - return Ok(Value::Expression(val)); + return Ok(Value::Exp(val)); } } pub fn expand_keys( - items: BTreeMap>>, -) -> ResultVec>> { + items: IndexMap>>, +) -> ResultVec>> { // expand any `{{key(`regex`)}}` expressions (these are arrays of possible keys) let items = items.map_expressions(&mut expand_keys_str)?; @@ -299,13 +299,15 @@ impl BindingInput { )?; let values = expand_foreach_values(foreach).into_iter().map(|values| { + // TODO: this is where we will eventually add the `for` variables + // to the expression scope instead of inserting the values directly let mut result = self.clone(); result.foreach = None; result .map_expressions(&mut |x| { Ok(values - .get(&x) - .map_or_else(|| Value::Expression(x), |ex| ex.clone())) + .get(&x.content) + .map_or_else(|| Value::Exp(x), |ex| ex.clone())) }) .expect("no errors") // since our mapping function has no errors }); @@ -315,8 +317,8 @@ impl BindingInput { } } -fn expand_foreach_values(foreach: BTreeMap>) -> Vec> { - let mut result = vec![BTreeMap::new()]; +fn expand_foreach_values(foreach: IndexMap>) -> Vec> { + let mut result = vec![IndexMap::new()]; for (k, vals) in foreach { result = result diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 11c6beab..fe0fd862 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -6,7 +6,7 @@ use regex::Regex; use serde::{Deserialize, Serialize}; use crate::error::{ErrorSet, Result, ResultVec, err}; -use crate::expression::value::{EXPRESSION, Expanding, TypedValue, Value}; +use crate::expression::value::{EXPRESSION, Expanding, Expression, TypedValue, Value}; use crate::util::{Merging, Resolving}; // @@ -151,13 +151,13 @@ impl Expanding for KeyBinding { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { Ok(match self { KeyBinding(TypedValue::Constant(_)) => self, KeyBinding(TypedValue::Variable(value)) => match value.map_expressions(f)? { interp @ Value::Interp(_) => KeyBinding(TypedValue::Variable(interp)), - exp @ Value::Expression(_) => KeyBinding(TypedValue::Variable(exp)), + exp @ Value::Exp(_) => KeyBinding(TypedValue::Variable(exp)), Value::String(val) => { valid_key_binding_str(&val)?; KeyBinding(TypedValue::Constant(val)) @@ -226,8 +226,8 @@ impl TryFrom for BindingReference { fn try_from(value: String) -> ResultVec { let value: Value = toml::Value::String(value).try_into()?; match value { - Value::Expression(x) => { - if let Some(captures) = BIND_VARIABLE.captures(&x) { + Value::Exp(x) => { + if let Some(captures) = BIND_VARIABLE.captures(&x.content) { Ok(BindingReference( captures.get(1).expect("variable name").as_str().to_string(), )) @@ -255,7 +255,7 @@ impl Expanding for BindingReference { fn map_expressions(self, _f: &mut F) -> ResultVec where Self: Sized, - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { return Ok(self); } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 48694895..cb15ccfa 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -1,11 +1,11 @@ #[allow(unused_imports)] use log::info; +use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; -use std::collections::BTreeMap; use std::collections::{HashMap, hash_map}; use toml::Spanned; @@ -15,7 +15,7 @@ use crate::bind::validation::BindingReference; use crate::err; use crate::error::{Error, ErrorContext, ResultVec, err}; use crate::expression::Scope; -use crate::expression::value::{Expanding, Value}; +use crate::expression::value::{Expanding, Expression, Value}; use crate::util::{Merging, Resolving}; /// @bindingField define @@ -86,7 +86,7 @@ pub struct DefineInput { /// args.after = "{{braces[captured].?after ?? captured}}" /// args.followCursor = true /// ``` - pub val: Option>>>, + pub val: Option>>>, /// @forBindingField define /// /// ## Command Definitions @@ -287,8 +287,8 @@ impl Define { binding }; - return binding.map_expressions(&mut |exp: String| { - let command = COMMAND_REF.captures(&exp); + return binding.map_expressions(&mut |exp: Expression| { + let command = COMMAND_REF.captures(&exp.content); if let Some(captures) = command { let name = captures.get(1).expect("variable name").as_str(); return Ok(self @@ -298,12 +298,12 @@ impl Define { .without_id() .into()); } - if BIND_REF.is_match(&exp) { + if BIND_REF.is_match(&exp.content) { return Err(err( "unexpected `bind.` reference; only valid inside `bind.default`", ))?; } - return Ok(Value::Expression(exp)); + return Ok(Value::Exp(exp)); }); } } @@ -343,7 +343,7 @@ mod tests { let args = foo.args.as_ref().unwrap().clone().into_inner(); assert_eq!( args, - Value::Table(BTreeMap::from([ + Value::Table(HashMap::from([ ("k".into(), Value::Integer(1)), ("h".into(), Value::Integer(2)) ])) @@ -355,7 +355,7 @@ mod tests { let commands = foobar.args.as_ref().unwrap().clone().into_inner(); assert_eq!( commands, - Value::Table(BTreeMap::from([( + Value::Table(HashMap::from([( "commands".into(), Value::Array(vec![ Value::String("foo".into()), diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index fa80904d..1cb2cd77 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -1,4 +1,5 @@ -use crate::bind::UNKNOWN_RANGE; +#[allow(unused_imports)] +use log::info; use core::ops::Range; use rhai::{self, EvalAltResult}; @@ -9,6 +10,8 @@ use thiserror::Error; use toml::Spanned; use wasm_bindgen::prelude::*; +use crate::bind::UNKNOWN_RANGE; + // // ---------------- Error Generation ---------------- // @@ -52,13 +55,8 @@ pub struct Error { #[derive(Debug, Clone)] pub enum Context { - Dynamic(&'static str), // additional message content to include - Range(Range), // the location of an error in a file - RhaiPosition(rhai::Position), // the location of an error within an expression - - // TODO: use this context once when/if expressions have a known span - #[allow(dead_code)] - ExpressionRange(Range), // the location of an expression in a file + Message(String), // additional message content to include + Range(Range), // the location of an error in a file } /// A `Spannable` can be interpreted as a range of byte offsets @@ -94,8 +92,8 @@ where type Error; /// `with_context` accepts a `Context` which the object should store fn with_context(self, context: Context) -> std::result::Result; - fn with_message(self, context: &'static str) -> std::result::Result { - return self.with_context(Context::Dynamic(context)); + fn with_message(self, context: impl ToString) -> std::result::Result { + return self.with_context(Context::Message(context.to_string())); } fn with_range(self, context: &impl Spannable) -> std::result::Result { if let Some(range) = context.range() { @@ -104,23 +102,6 @@ where return self.with_context(Context::Range(UNKNOWN_RANGE)); } } - // TODO: use this once we have ranges for expressions - #[allow(dead_code)] - fn with_expression_range( - self, - context: &impl Spannable, - ) -> std::result::Result { - if let Some(range) = context.range() { - return self.with_context(Context::ExpressionRange(range)); - } else { - return self.with_context(Context::ExpressionRange(UNKNOWN_RANGE)); - } - } - // TODO: use this once we have ranges for expressions - #[allow(dead_code)] - fn with_pos(self, context: rhai::Position) -> std::result::Result { - return self.with_context(Context::RhaiPosition(context)); - } } impl ErrorContext for Result { @@ -152,10 +133,7 @@ impl> From for Error { impl From> for Error { fn from(value: Box) -> Error { - let error = RawError::Dynamic(value.to_string()).into(); - let mut contexts = SmallVec::new(); - contexts.push(Context::RhaiPosition(value.position())); - return Error { error, contexts }; + return RawError::Dynamic(value.to_string()).into(); } } @@ -257,18 +235,12 @@ impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { for context in &self.contexts { match context { - Context::Dynamic(str) => { + Context::Message(str) => { write!(f, "{}\n", str)?; } Context::Range(range) => { write!(f, "byte range {:?}\n", range)?; } - Context::ExpressionRange(range) => { - write!(f, "byte range of expression {:?}\n", range)?; - } - Context::RhaiPosition(pos) => { - write!(f, "expression pos: {:?}\n", pos)?; - } } } self.error.fmt(f)?; @@ -290,21 +262,21 @@ fn range_to_pos(range: &Range, offsets: &StringOffsets) -> CharRange { } fn resolve_rhai_pos_from_expression_range( - rhai_pos: Option, - char_line_range: Option, -) -> Option { - if let (Some(rpos), Some(cl_range)) = (rhai_pos, &char_line_range) { - if let Some(line) = rpos.line() { - if line > 1 { - let char_line_start = Pos { - line: cl_range.start.line + line - 1, - col: cl_range.start.col + rpos.position().unwrap_or_default(), - }; - return Some(CharRange { - start: char_line_start, - end: char_line_start, - }); - } + rhai_pos: rhai::Position, + char_line_range: CharRange, +) -> CharRange { + if let Some(line) = rhai_pos.line() { + info!("rhai line: {line}"); + info!("rhai char: {}", rhai_pos.position().unwrap_or_default()); + if line >= 1 { + let char_line_start = Pos { + line: char_line_range.start.line + line - 1, + col: char_line_range.start.col + rhai_pos.position().unwrap_or_default(), + }; + return CharRange { + start: char_line_start, + end: char_line_start, + }; } } return char_line_range; @@ -325,40 +297,35 @@ impl Error { message_buf.push_str(toml.message()); char_line_range = toml.span().map(|r| range_to_pos(&r, &offsets)); } + RawError::ExpressionParsing(rhai) => { + rhai_pos = Some(rhai.position()); + message_buf.push_str(&self.error.to_string()); + } _ => message_buf.push_str(&self.error.to_string()), }; for context in &self.contexts { match context { - Context::Dynamic(str) => message_buf.push_str(str), + Context::Message(str) => message_buf.push_str(str), Context::Range(new_range) => { - // usually the new range is the one we want to use *but* the old range - // is strictly more specific than the new one, we keep the old range - if !(range.len() < new_range.len() - && (new_range.contains(&range.start) || new_range.contains(&range.end))) - { + // usually the old range is the one we want to use *but* if the new + // range is strictly more specific than the new one, we use the new + // range + info!("consolidating range: {new_range:?}"); + if range.contains(&new_range.start) && range.contains(&new_range.end) { range = new_range.clone(); - let range_pos = range_to_pos(&range, &offsets); - char_line_range = Some(CharRange { - start: range_pos.start, - end: range_pos.end, - }); + let new_char_line_range = range_to_pos(&new_range, &offsets); + if let Some(pos) = rhai_pos { + char_line_range = Some(resolve_rhai_pos_from_expression_range( + pos, + new_char_line_range, + )); + rhai_pos = None; + } else { + char_line_range = Some(new_char_line_range); + } + info!("new range: {:?}", char_line_range) } } - Context::ExpressionRange(new_range) => { - // we can now resolve the `Context::RhaiPosition`, which is relative to - // the start of an expression, to a specific file location, because we - // have the range of the full expression. - char_line_range = Some(range_to_pos(&new_range, &offsets)); - char_line_range = - resolve_rhai_pos_from_expression_range(rhai_pos, char_line_range); - } - Context::RhaiPosition(pos) => { - // when we see a rhai range all we know is where, relative to the start - // of the expression the error was raised. We have to wait until a - // future iteration of this `for` loop when we find a specific file - // location where the expression begins. - rhai_pos = Some(pos.clone()); - } }; } if let Some(cl_range) = char_line_range { diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 88c9b993..f76e97c1 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -2,6 +2,9 @@ pub mod value; +#[allow(unused_imports)] +use log::info; + use std::collections::{HashMap, VecDeque}; use rhai::Dynamic; @@ -9,8 +12,8 @@ use serde::Serialize; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ - bind::command::Command, err, error::Result, error::ResultVec, expression::value::Expanding, - expression::value::Value, + bind::command::Command, err, error::ErrorContext, error::Result, error::ResultVec, + expression::value::Expanding, expression::value::Value, }; /// @file expressions/index.md @@ -19,8 +22,12 @@ use crate::{ /// /// You can use expressions in a number of places inside a [bind](/bindings/bind) /// definition. An expression is a snippet of code surrounded by double curly braces {{like + this}} that occurs within a TOML string. Expressions can evaluate -/// to any valid TOML object when the entire string is an expression +/// v-pre>{{like + this}} that occurs within a TOML string. +/// +/// When the string is comprised entirely of a single expression, it can evaluate to any +/// valid TOML object. +/// +/// **Example** /// /// ```toml /// [[define.val]] @@ -50,28 +57,41 @@ use crate::{ /// ``` /// /// Valid expressions are a simple subset of [Rhai](https://rhai.rs/book/ref/index.html). -/// You cannot execute statements, set variables, use loops, or define functions. If you -/// find yourself wanting to write an elaborate expression, your goal is probably better -/// accomplished by writing an [extension](https://code.visualstudio.com/api) and running -/// the extension defined-command. +/// You can only evaluate expressions not statements, and you cannot set variables, use +/// loops, or define functions. If you find yourself wanting to write an elaborate +/// expression, your goal is probably better accomplished by writing an +/// [extension](https://code.visualstudio.com/api) and running the extension +/// defined-command. /// /// There are two points at which an expression can be evaluated: while parsing the master /// keybinding file (e.g. making use of [foreach](/bindings/bind#foreach-clauses)) or at /// runtime: when the user presses a key. /// -/// ## Parse-time Evaluation +/// ## Read-time Evaluation /// -/// Parse-time expressions are generally quite limited in terms of what values are in scope -/// within the expression. The individual fields of `bind` document the scope of a given -/// parse-time expression. +/// Read-time expressions are computed directly after a keybinding file (and any user +/// defined bindings) have been loaded. The following values are in scope: +/// +/// - Any field defined in a [`[[define.val]]`](/bindings/define) section. These variables +/// are all stored under the top-level `val.` object. +/// - Variables defined by [`foreach`](/bindings/bind#foreach-clauses) +/// - `keys([regex]):` returns all keys matching the regular expression defined by the given +/// string +/// - `all_prefixes()`: returns an array of strings of all keybinding prefixes defined by +/// the current set of keybindigs +/// - `all_modes()`: returns an array of strings all keybinding modes defined by the current +/// keybinding set +/// - `all_modes_but([exclusions])`: given an array of strings of excluded modes, returns +/// all keybinding modes defined by the current keybinding set that are not among these +/// exclusions. /// /// ## Run-time Evaluation /// -/// Expressions that get evaluated at run time are clearly denoted as such with a ⚡ emoji. -/// They are more expressive, and have access to the following values: +/// Fields for which expressions are evaluated at run time are clearly denoted as such with +/// a ⚡ symbol. The are computed directly after a user presses the given keybinding. They +/// have access to the following values: /// -/// - Any field defined in a [`[[define.val]]`](/bindings/define) section. These variables -/// are all stored under the top-level `val.` object. +/// - any value available at read-time (see above) /// - `code.editorHasSelection`: true if there is any selection, false otherwise /// - `code.editorHasMultipleSelections`: true if there are multiple selections, false /// otherwise @@ -119,21 +139,22 @@ impl Scope { self.state.set_or_push(k, v.clone()); } return Ok(obj.clone().map_expressions(&mut |expr| { - let ast = &self.asts[&expr]; - let value: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; - let result_value: Value = value.clone().try_into()?; - return Ok(result_value); + let ast = &self.asts[&expr.content]; + let dynamic: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; + let result_value: std::result::Result = dynamic.clone().try_into(); + let value = result_value.with_message(format!(" while evaluating:\n{expr}"))?; + return Ok(value); })?); } - // TODO: revelation, we don't actually have a way to get an expressions' precise - // position because of how parsing works. *MAYBE* we could write a custom - // deserializer or value::Value, but that seems very complex pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { x.clone().map_expressions(&mut |expr| { - let ast = self.engine.compile_expression(expr.clone())?; - self.asts.insert(expr.clone(), ast); - return Ok(Value::Expression(expr)); + let ast = self + .engine + .compile_expression(expr.content.clone()) + .with_range(&expr.span)?; + self.asts.insert(expr.content.clone(), ast); + return Ok(Value::Exp(expr)); })?; return Ok(()); } @@ -201,3 +222,66 @@ impl Scope { // TODO: function to evaluate args of replay and return a range of expressions // to replay in type script } + +mod tests { + use super::*; + use test_log::test; + + #[test] + fn expression_paren_error() { + let data = r#" + joe = "{{(1 + 3}}" + "#; + let value: Value = toml::from_str(data).unwrap(); + info!("{value:?}"); + + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + + assert_eq!("3", val); + assert!(message.contains("Expecting ')'")); + } + + #[test] + fn expression_operator_error() { + let data = r#" + joe = "{{(1 # 3}}" + "#; + let value: Value = toml::from_str(data).unwrap(); + info!("{value:?}"); + + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col + 1)..=(range.end.col + 1)].to_string(); + + assert_eq!("#", val); + assert!(message.contains("Unknown operator")) + } + + #[test] + fn expression_bracket_error() { + let data = r#" + joe = "{{joe bob {{ bill}}" + "#; + let value: std::result::Result = toml::from_str(data); + let err = value.unwrap_err(); + info!("err: {err:?}") + } + + #[test] + fn expression_bracket_error_2() { + let data = r#" + joe = "{{joe bob bill}} bob fob}}" + "#; + let value: std::result::Result = toml::from_str(data); + let err = value.unwrap_err(); + info!("err: {err:?}") + } +} diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index f2a4f5ba..087bbfc5 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -1,21 +1,24 @@ #[allow(unused_imports)] use log::info; +use core::ops::Range; +use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; -use std::collections::BTreeMap; -use std::io; +use smallvec::SmallVec; +use std::collections::HashMap; use std::io::Write; use toml::Spanned; +use crate::bind::UNKNOWN_RANGE; use crate::err; -use crate::error::{ErrorContext, ErrorSet, Result, ResultVec, flatten_errors}; +use crate::error::{ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; // -// ---------------- `Value` ---------------- +// ================ Value ================ // /// `Value` is an expressive type that can be used to represent any TOML / JSON object with @@ -24,24 +27,393 @@ use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; /// to represent parsed TOML data, expand the expressions in them, and translate /// those values to JSON and/or Rhai `Dynaamic` objects. -#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)] -#[serde(try_from = "toml::Value")] +#[derive(Serialize, Debug, Clone, PartialEq)] pub enum Value { Integer(i32), Float(f64), String(String), Boolean(bool), Array(Vec), - Table(BTreeMap), + Table(HashMap), Interp(Vec), - // TODO: could optimize further by using an internned string (simplifying AST lookup) - // TODO: include a span so that we can improve error messages - Expression(String), + Exp(Expression), } -impl Default for Value { - fn default() -> Self { - return Value::Table(BTreeMap::new()); +// +// ---------------- Value: Expressions ---------------- +// + +/// Expression's within a value are composed of both the expression code but also a span +/// (usually) indicating where the expression is located in a source file and a scope, which +/// describes any locally resolved values, such as from the `foreach` field of `[[bind]]` +#[derive(Deserialize, Serialize, Debug, Clone)] +pub struct Expression { + pub content: String, + pub span: Range, + pub scope: SmallVec<[(String, BareValue); 8]>, +} + +impl std::fmt::Display for Expression { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { + write!(fmt, "{}", "{{")?; + self.content.fmt(fmt)?; + write!(fmt, "{}", "}}")?; + return Ok(()); + } +} + +impl PartialEq for Expression { + fn eq(&self, other: &Self) -> bool { + if self.content != other.content { + return false; + } + // TODO: make this more efficient + let self_scope: HashMap<_, _> = self.scope.clone().into_iter().collect(); + let other_scope: HashMap<_, _> = other.scope.clone().into_iter().collect(); + return self_scope == other_scope; + } +} + +// +// ---------------- Value: Deserialization ---------------- +// + +impl<'de> Deserialize<'de> for Value { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + let bare_value = BareValue::deserialize(deserializer)?; + match Value::new(bare_value, None) { + // TODO: could improve error handling here once we have a proper + // error type for the kinds of errors we expect to show here + Err(e) => Err(serde::de::Error::custom(e.to_string())), + Ok(x) => Ok(x), + } + } +} + +#[derive(Serialize, Debug, Clone, PartialEq)] +pub enum BareValue { + Integer(i32), + Float(f64), + String(String), + Datetime(toml::value::Datetime), + Boolean(bool), + Array(Vec), + Table(HashMap>), +} + +// Manual implementation of `Deserialize` is required here to capture `Spanned` within +// `Table` values. Note: `toml`'s has a limitation that it cannot have `Spanned` `Array` +// values in a dynamic type like `BareValue`. To work around this limitation we would +// probably need to use a different deserialization approach that did not use `serde` +// directly. Instead we simply accept that error messages for expressions will be +// less precise when they occur as a direct child of an array. +impl<'de> serde::de::Deserialize<'de> for BareValue { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::de::Deserializer<'de>, + { + struct ValueVisitor; + + impl<'de> serde::de::Visitor<'de> for ValueVisitor { + type Value = BareValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("any valid TOML value") + } + + fn visit_bool(self, value: bool) -> std::result::Result { + Ok(BareValue::Boolean(value)) + } + + fn visit_i64( + self, + value: i64, + ) -> std::result::Result { + if i32::try_from(value).is_ok() { + Ok(BareValue::Integer(value as i32)) + } else { + Err(serde::de::Error::custom( + "i64 value was too large (must fit in i32)", + )) + } + } + + fn visit_u64( + self, + value: u64, + ) -> std::result::Result { + if i32::try_from(value).is_ok() { + Ok(BareValue::Integer(value as i32)) + } else { + Err(serde::de::Error::custom( + "u64 value was too large (must fit in i32", + )) + } + } + + fn visit_u32( + self, + value: u32, + ) -> std::result::Result { + if i32::try_from(value).is_ok() { + Ok(BareValue::Integer(value as i32)) + } else { + Err(serde::de::Error::custom( + "u32 value was too large (must fit in i32)", + )) + } + } + + fn visit_i32(self, value: i32) -> std::result::Result { + Ok(BareValue::Integer(value.into())) + } + + fn visit_f64(self, value: f64) -> std::result::Result { + Ok(BareValue::Float(value)) + } + + fn visit_str(self, value: &str) -> std::result::Result { + Ok(BareValue::String(value.into())) + } + + fn visit_string(self, value: String) -> std::result::Result { + Ok(BareValue::String(value)) + } + + fn visit_some(self, deserializer: D) -> std::result::Result + where + D: serde::de::Deserializer<'de>, + { + serde::de::Deserialize::deserialize(deserializer) + } + + fn visit_seq(self, mut visitor: V) -> std::result::Result + where + V: serde::de::SeqAccess<'de>, + { + let mut vec = Vec::new(); + while let Some(elem) = visitor.next_element()? { + vec.push(elem); + } + Ok(BareValue::Array(vec)) + } + + fn visit_map(self, mut visitor: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let key = match toml_datetime::de::VisitMap::next_key_seed(&mut visitor)? { + Some(toml_datetime::de::VisitMap::Datetime(datetime)) => { + return Ok(BareValue::Datetime(datetime)); + } + Option::None => return Ok(BareValue::Table(HashMap::new())), + Some(toml_datetime::de::VisitMap::Key(key)) => key, + }; + let mut map = HashMap::new(); + map.insert(key.into_owned(), visitor.next_value()?); + while let Some(key) = visitor.next_key::()? { + match map.entry(key) { + std::collections::hash_map::Entry::Vacant(vacant) => { + vacant.insert(visitor.next_value()?); + } + std::collections::hash_map::Entry::Occupied(occupied) => { + let msg = format!("duplicate key: `{}`", occupied.key()); + return Err(serde::de::Error::custom(msg)); + } + } + } + Ok(BareValue::Table(map)) + } + } + + deserializer.deserialize_any(ValueVisitor) + } +} + +lazy_static! { + pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*?)\}\}").unwrap(); +} + +impl Value { + fn new(value: BareValue, range: Option>) -> Result { + return Ok(match value { + BareValue::Boolean(x) => Value::Boolean(x), + BareValue::Float(x) => Value::Float(x), + BareValue::Integer(x) => Value::Integer(x), + BareValue::Datetime(x) => Value::String(x.to_string()), + BareValue::String(x) => string_to_expression(x, range)?, + BareValue::Array(toml_values) => { + let values = toml_values.into_iter().map(|x| { + return Ok(Value::new(x, None)?); + }); + Value::Array(values.collect::>()?) + } + BareValue::Table(toml_kv) => { + let kv = toml_kv.into_iter().map(|(k, v)| { + let span = v.span(); + return Ok((k, Value::new(v.into_inner(), Some(span))?)); + }); + Value::Table(kv.collect::>()?) + } + }); + } +} + +fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match) -> Result { + if let Some(parent_span) = maybe_parent_span { + let r = m.range(); + let exp_span = (parent_span.start + r.start)..(parent_span.start + r.end); + let content: String = m.as_str().into(); + if content.contains("{{") { + return Err(RawError::Static("unexpected `{{`")).with_range(&exp_span)?; + } + return Ok(Value::Exp(Expression { + content, + span: exp_span, + scope: SmallVec::new(), + })); + } else { + let content: String = m.as_str().into(); + if content.contains("{{") { + return Err(RawError::Static("unexpected `{{`"))?; + } + return Ok(Value::Exp(Expression { + content, + span: UNKNOWN_RANGE, + scope: SmallVec::new(), + })); + } +} + +fn string_to_expression(x: String, span: Option>) -> Result { + let exprs = EXPRESSION.captures_iter(&x); + // there are multiple expressions interpolated into the string + let mut interps = Vec::new(); + let mut last_match = 0..0; + // TODO: check for unmatched `{{` or `}}` + // push rest + for expr in exprs { + let r = expr.get(0).expect("full match").range(); + if r.len() == x.len() { + return match_to_expression(&span, expr.get(1).expect("variable name")); + } + if last_match.end < r.start { + interps.push(Value::String(x[last_match.end..r.start].into())); + } + last_match = r; + + interps.push(match_to_expression( + &span, + expr.get(1).expect("variable name"), + )?); + } + if last_match.start == 0 && last_match.end == 0 { + if x.contains("{{") { + let result = Err(RawError::Static("unexpected `{{`")); + if let Some(r) = span { + return result.with_range(&r); + } else { + result?; + } + } else if x.contains("}}") { + let result = Err(RawError::Static("unexpected `}}`")); + if let Some(r) = span { + return result.with_range(&r); + } else { + result?; + } + } + return Ok(Value::String(x)); + } + if last_match.end < x.len() { + interps.push(Value::String(x[last_match.end..].into())); + } + return Ok(Value::Interp(interps)); +} + +fn interp_to_string(interps: Vec) -> String { + let mut result = String::new(); + for v in interps { + match v { + Value::String(x) => result.push_str(&x), + Value::Exp(Expression { content: x, .. }) => { + result.push_str(&format!("{}{x}{}", "{{", "}}")); + } + other @ _ => { + let toml: toml::Value = other.into(); + let mut other_str = String::new(); + match toml.serialize(toml::ser::ValueSerializer::new(&mut other_str)) { + Err(_) => result.push_str(""), + Ok(_) => (), + }; + result.push_str(&other_str) + } + } + } + return result; +} + +// +// ---------------- Value: Conversion ---------------- +// + +impl TryFrom for BareValue { + type Error = ErrorSet; + fn try_from(value: toml::Value) -> ResultVec { + return Ok(match value { + toml::Value::Boolean(x) => BareValue::Boolean(x), + toml::Value::Float(x) => BareValue::Float(x), + toml::Value::Integer(x) => BareValue::Integer({ + if i32::try_from(x).is_ok() { + x as i32 + } else { + Err(RawError::Static( + "i64 value was too large (must fit in i32)", + ))?; + 0 + } + }), + toml::Value::Datetime(x) => BareValue::String(x.to_string()), + toml::Value::String(x) => BareValue::String(x), + toml::Value::Array(toml_values) => { + let values = flatten_errors(toml_values.into_iter().map(|x| { + return Ok(x.try_into::()?); + }))?; + BareValue::Array(values) + } + toml::Value::Table(toml_kv) => { + let kv = flatten_errors(toml_kv.into_iter().map(|(k, v)| { + Ok((k, Spanned::new(UNKNOWN_RANGE, v.try_into::()?))) + }))?; + BareValue::Table(kv.into_iter().collect()) + } + }); + } +} + +impl From for toml::Value { + fn from(value: Value) -> toml::Value { + return match value { + Value::Exp(Expression { content: x, .. }) => panic!("Unresolved expression {x}"), + Value::Interp(interps) => { + panic!("Unresolved interpolation {}", interp_to_string(interps)) + } + Value::Array(items) => { + let new_items = items.into_iter().map(|it| it.into()).collect(); + toml::Value::Array(new_items) + } + Value::Table(kv) => { + let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); + toml::Value::Table(new_kv) + } + Value::Boolean(x) => toml::Value::Boolean(x), + Value::Float(x) => toml::Value::Float(x), + Value::Integer(x) => toml::Value::Integer(x as i64), + Value::String(x) => toml::Value::String(x), + }; } } @@ -62,8 +434,8 @@ impl From for Dynamic { map.into() } // the from here results in an opaque custom type - Value::Expression(x) => Dynamic::from(x), - Value::Interp(x) => Dynamic::from(x), + val @ Value::Exp(_) => Dynamic::from(val), + val @ Value::Interp(..) => Dynamic::from(val), }; } } @@ -87,7 +459,7 @@ impl TryFrom for Value { .clone() .into_iter() .map(|(k, v)| Ok((k.as_str().to_string(), Value::try_from(v.to_owned())?))) - .collect::>>()?; + .collect::>>()?; return Ok(Value::Table(values)); } else if value.is_bool() { return Ok(Value::Boolean(value.as_bool().expect("boolean"))); @@ -109,91 +481,13 @@ impl TryFrom for Value { } } -lazy_static! { - pub static ref EXPRESSION: Regex = Regex::new(r"\{\{(.*?)\}\}").unwrap(); -} - -impl TryFrom for Value { - type Error = ErrorSet; - fn try_from(value: toml::Value) -> ResultVec { - return Ok(match value { - toml::Value::Boolean(x) => Value::Boolean(x), - toml::Value::Float(x) => Value::Float(x), - toml::Value::Integer(x) => Value::Integer({ - if x > (std::f64::MAX as i64) || x < (std::f64::MIN as i64) { - return Err(err!( - "{x} cannot be expressed as a 64-bit floating point number.", - ))?; - } else { - x.clone() as i32 - } - }), - toml::Value::Datetime(x) => Value::String(x.to_string()), - toml::Value::String(x) => string_to_expression(x), - toml::Value::Array(toml_values) => { - let values = flatten_errors(toml_values.into_iter().map(|x| { - return Ok(x.try_into::()?); - }))?; - Value::Array(values) - } - toml::Value::Table(toml_kv) => { - let kv = flatten_errors( - toml_kv - .into_iter() - .map(|(k, v)| Ok((k, v.try_into::()?))), - )?; - Value::Table(kv.into_iter().collect()) - } - }); - } -} - -fn string_to_expression(x: String) -> Value { - let exprs = EXPRESSION.captures_iter(&x); - // there are multiple expressions interpolated into the string - let mut interps = Vec::new(); - let mut last_match = 0..0; - // push rest - for expr in exprs { - let r = expr.get(0).expect("full match").range(); - if r.len() == x.len() { - return Value::Expression(expr.get(1).expect("variable name").as_str().into()); - } - if last_match.end < r.start { - interps.push(Value::String(x[last_match.end..r.start].into())); - } - last_match = r; - - let var_str = expr.get(1).expect("variable name").as_str(); - interps.push(Value::Expression(var_str.into())); - } - if last_match.start == 0 && last_match.end == 0 { - return Value::String(x); - } - if last_match.end < x.len() { - interps.push(Value::String(x[last_match.end..].into())); - } - return Value::Interp(interps); -} +// +// ---------------- Value: Traits ---------------- +// -impl From for toml::Value { - fn from(value: Value) -> toml::Value { - return match value { - Value::Expression(x) => panic!("Unresolved expression {x}"), - Value::Interp(interps) => panic!("Unresolved interpolation {interps:?}"), - Value::Array(items) => { - let new_items = items.into_iter().map(|it| it.into()).collect(); - toml::Value::Array(new_items) - } - Value::Table(kv) => { - let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); - toml::Value::Table(new_kv) - } - Value::Boolean(x) => toml::Value::Boolean(x), - Value::Float(x) => toml::Value::Float(x), - Value::Integer(x) => toml::Value::Integer(x as i64), - Value::String(x) => toml::Value::String(x), - }; +impl Default for Value { + fn default() -> Self { + return Value::Table(HashMap::new()); } } @@ -237,6 +531,8 @@ impl Resolving for Value { impl Resolving for Value { fn resolve(self, name: &'static str) -> ResultVec { + // TODO: this is where we will eventually evaluate expressions + // *wihtin* their scope self.require_constant() .with_message("for ") .with_message(name)?; @@ -245,7 +541,7 @@ impl Resolving for Value { } // -// ---------------- `Expanding` trait ---------------- +// ================ `Expanding` trait ================ // /// The `Expanding` trait is used to expand expressions contained within an object @@ -260,7 +556,7 @@ pub trait Expanding { fn map_expressions(self, f: &mut F) -> ResultVec where Self: Sized, - F: FnMut(String) -> Result; + F: FnMut(Expression) -> Result; /// returns true if there are no `Value::Expression` enum variants in any contained /// `Value` @@ -277,13 +573,30 @@ pub trait Expanding { } } -impl Expanding for BTreeMap { +impl Expanding for HashMap { fn is_constant(&self) -> bool { self.values().all(|v| v.is_constant()) } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, + { + return Ok(flatten_errors( + self.into_iter() + .map(|(k, v)| Ok((k, v.map_expressions(f)?))), + )? + .into_iter() + .collect()); + } +} + +impl Expanding for IndexMap { + fn is_constant(&self) -> bool { + self.values().all(|v| v.is_constant()) + } + fn map_expressions(self, f: &mut F) -> ResultVec + where + F: FnMut(Expression) -> Result, { return Ok(flatten_errors( self.into_iter() @@ -297,7 +610,7 @@ impl Expanding for BTreeMap { impl Expanding for Value { fn is_constant(&self) -> bool { match self { - Value::Expression(_) => false, + Value::Exp(Expression { .. }) => false, Value::Interp(_) => false, Value::Array(items) => items.iter().all(|it| it.is_constant()), Value::Table(kv) => kv.values().all(|it| it.is_constant()), @@ -306,11 +619,10 @@ impl Expanding for Value { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { - // XXX: we could optimize by pruning constant branches return Ok(match self { - Value::Expression(x) => f(x)?, + Value::Exp(x) => f(x)?, Value::Interp(interps) => { let value: Vec = interps.map_expressions(f)?.into(); if value.is_constant() { @@ -345,7 +657,7 @@ impl Expanding for Spanned { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { let span = self.span(); Ok(Spanned::new( @@ -361,7 +673,7 @@ impl Expanding for Vec { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { Ok(flatten_errors( self.into_iter().map(|x| x.map_expressions(f)), @@ -375,7 +687,7 @@ impl Expanding for Plural { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { return Ok(Plural(self.0.map_expressions(f)?)); } @@ -390,7 +702,7 @@ impl Expanding for Required { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { return Ok(match self { Required::DefaultValue => self, @@ -408,7 +720,7 @@ impl Expanding for Option { } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { return Ok(match self { Option::None => self, @@ -418,7 +730,7 @@ impl Expanding for Option { } // -// ---------------- `TypedValue` objects ---------------- +// ================ `TypedValue` objects ================ // /// A `TypedValue` wraps `Value`, requiring it to evaluate to an object that can be @@ -448,7 +760,7 @@ where { type Error = ErrorSet; fn try_from(value: toml::Value) -> ResultVec> { - io::stdout().flush().unwrap(); + std::io::stdout().flush().unwrap(); let val: Value = value.try_into()?; return Ok(val.try_into()?); @@ -461,7 +773,7 @@ where { type Error = ErrorSet; fn try_from(value: Value) -> ResultVec> { - io::stdout().flush().unwrap(); + std::io::stdout().flush().unwrap(); return match value.require_constant() { Err(_) => Ok(TypedValue::Variable(value)), Ok(_) => { @@ -485,7 +797,7 @@ where } fn map_expressions(self, f: &mut F) -> ResultVec where - F: FnMut(String) -> Result, + F: FnMut(Expression) -> Result, { return Ok(match self { TypedValue::Variable(v) => { @@ -616,3 +928,16 @@ impl Merging for TypedValue { return new; } } + +mod tests { + use super::*; + + #[test] + fn parse_datetime() { + let data = r#" + joe = 1979-05-27T07:32:00Z + "#; + let value: std::result::Result = toml::from_str(data); + assert!(value.is_ok()); + } +} diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index f2c81b73..954aab0b 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -213,8 +213,11 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { #[cfg(test)] mod tests { use super::*; + use crate::bind::UNKNOWN_RANGE; + use crate::expression::value::Expression; use crate::expression::value::Value; - use std::collections::BTreeMap; + use smallvec::SmallVec; + use std::collections::HashMap; use test_log::test; #[test] @@ -273,9 +276,16 @@ mod tests { assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, - Value::Table(BTreeMap::from([ + Value::Table(HashMap::from([ ("a".into(), Value::Integer(1)), - ("b".into(), Value::Expression("val.foo_string".into())), + ( + "b".into(), + Value::Exp(Expression { + content: "val.foo_string".into(), + span: UNKNOWN_RANGE, + scope: SmallVec::new(), + }) + ), ])) ); assert_eq!(result.bind[0].commands[1].command, "bar"); @@ -314,9 +324,16 @@ mod tests { assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, - Value::Table(BTreeMap::from([ + Value::Table(HashMap::from([ ("a".into(), Value::Integer(1)), - ("b".into(), Value::Expression("val.foo_string".into())), + ( + "b".into(), + Value::Exp(Expression { + content: "val.foo_string".into(), + span: UNKNOWN_RANGE, + scope: SmallVec::new(), + }) + ), ])) ); assert_eq!(result.bind[0].commands[1].command, "bar"); @@ -344,7 +361,7 @@ mod tests { assert_eq!(result.bind[i].doc.name, expected_name[i]); assert_eq!( result.bind[i].commands[0].args, - Value::Table(BTreeMap::from([( + Value::Table(HashMap::from([( "value".to_string(), Value::String(expected_value[i].clone()) ),])) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 3c4613d9..4903326a 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -1,13 +1,13 @@ #[allow(unused_imports)] use log::info; +use indexmap::IndexMap; use serde::{Deserialize, Serialize}; -use std::collections::BTreeMap; +use std::collections::HashMap; use toml::{Spanned, Value}; use crate::err; use crate::error::{Error, ErrorContext, Result, ResultVec, flatten_errors}; -use crate::expression::value::TypedValue; // // ---------------- Merging ---------------- @@ -35,23 +35,37 @@ impl Merging for toml::Table { new.into_iter().partition(|(k, _)| self.get(k).is_some()); let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { Some(new_v) => (k, v.merge(new_v)), - None => (k, v), + Option::None => (k, v), }); return pairs.chain(to_append.into_iter()).collect(); } } -impl Merging for BTreeMap { +impl Merging for HashMap { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, new: Self) -> Self { + let (mut to_merge, to_append): (HashMap<_, _>, HashMap<_, _>) = + new.into_iter().partition(|(k, _)| self.get(k).is_some()); + let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { + Some(new_v) => (k, v.merge(new_v)), + Option::None => (k, v), + }); + return pairs.chain(to_append.into_iter()).collect(); + } +} + +impl Merging for IndexMap { fn coalesce(self, new: Self) -> Self { return new; } - // BUG!!!: we need to add the new keys that aren't in self to `pairs` fn merge(self, new: Self) -> Self { - let (mut to_merge, to_append): (BTreeMap<_, _>, BTreeMap<_, _>) = + let (mut to_merge, to_append): (IndexMap<_, _>, IndexMap<_, _>) = new.into_iter().partition(|(k, _)| self.get(k).is_some()); let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { Some(new_v) => (k, v.merge(new_v)), - None => (k, v), + Option::None => (k, v), }); return pairs.chain(to_append.into_iter()).collect(); } @@ -127,9 +141,9 @@ impl Merging for Option { return match new { Some(newval) => match self { Some(oldval) => Some(oldval.merge(newval)), - None => Some(newval), + Option::None => Some(newval), }, - None => self, + Option::None => self, }; } @@ -241,7 +255,7 @@ where fn resolve(self, name: &'static str) -> ResultVec { match self { Some(x) => x.resolve(name), - None => Ok(U::default()), + Option::None => Ok(U::default()), } } } @@ -253,7 +267,7 @@ where fn resolve(self, name: &'static str) -> ResultVec> { match self { Some(x) => Ok(Some(x.resolve(name)?)), - None => Ok(None), + Option::None => Ok(None), } } } @@ -279,7 +293,7 @@ where type Error = Error; fn try_from(value: Option) -> Result { match value { - None => Ok(Required::DefaultValue), + Option::None => Ok(Required::DefaultValue), Some(x) => Ok(Required::Value(toml::Value::try_into(x)?)), } } From d4ab53201ca21799a4f107245e8f62ae0b3ddc90 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 24 Sep 2025 23:19:08 -0400 Subject: [PATCH 55/79] working tests for expression errors Created using spr 1.3.6-beta.1 --- notes.md | 6 +-- src/rust/parsing/src/bind/command.rs | 1 + src/rust/parsing/src/error.rs | 4 -- src/rust/parsing/src/expression.rs | 69 ++++++++++++++++++++---- src/rust/parsing/src/expression/value.rs | 67 +++++++++++++++-------- src/rust/parsing/src/file.rs | 2 + 6 files changed, 111 insertions(+), 38 deletions(-) diff --git a/notes.md b/notes.md index 258f93a4..d3aa88b1 100644 --- a/notes.md +++ b/notes.md @@ -160,7 +160,7 @@ Integration test debugging: - [X] implement support for tags on `bind` (for filter them) - [X] implement support for `skipWhen` in `command` - [ ] improve expression evaluation - - [ ] improve error reporting in expressions + - [X] improve error reporting in expressions - [X] support spans for expressions - [X] create a `RawValue` that tracks spans - [X] try to implement with just the Span for expressions tracked @@ -178,9 +178,9 @@ Integration test debugging: - [X] inject expression spans and rhai positions into error contexts - [X] implementation - [X] test that expressions spans properly resolve - - [ ] check for unmatched `{{` and `}}` in strings + - [X] check for unmatched `{{` and `}}` in strings - [X] implementation - - [~] test that unmatched mustaches raise an error + - [X] test that unmatched mustaches raise an error - need to defer these errors until we run parse_asts so that we can get proper span information without having to pass errors through a deserialization object diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index c3664c0a..13d12efa 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -299,6 +299,7 @@ mod tests { TypedValue::Variable(Value::Exp(Expression { content: "count > 2".to_string(), span: UNKNOWN_RANGE, + error: None, scope: smallvec::SmallVec::new(), })) ); diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 1cb2cd77..c4fd1e21 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -266,8 +266,6 @@ fn resolve_rhai_pos_from_expression_range( char_line_range: CharRange, ) -> CharRange { if let Some(line) = rhai_pos.line() { - info!("rhai line: {line}"); - info!("rhai char: {}", rhai_pos.position().unwrap_or_default()); if line >= 1 { let char_line_start = Pos { line: char_line_range.start.line + line - 1, @@ -310,7 +308,6 @@ impl Error { // usually the old range is the one we want to use *but* if the new // range is strictly more specific than the new one, we use the new // range - info!("consolidating range: {new_range:?}"); if range.contains(&new_range.start) && range.contains(&new_range.end) { range = new_range.clone(); let new_char_line_range = range_to_pos(&new_range, &offsets); @@ -323,7 +320,6 @@ impl Error { } else { char_line_range = Some(new_char_line_range); } - info!("new range: {:?}", char_line_range) } } }; diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index f76e97c1..8ce61ced 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -149,6 +149,9 @@ impl Scope { pub(crate) fn parse_asts(&mut self, x: &(impl Expanding + Clone)) -> ResultVec<()> { x.clone().map_expressions(&mut |expr| { + if let Some(e) = expr.error { + return Err(e)?; + } let ast = self .engine .compile_expression(expr.content.clone()) @@ -233,7 +236,6 @@ mod tests { joe = "{{(1 + 3}}" "#; let value: Value = toml::from_str(data).unwrap(); - info!("{value:?}"); let mut scope = Scope::new(); let err = scope.parse_asts(&value).unwrap_err(); @@ -252,7 +254,6 @@ mod tests { joe = "{{(1 # 3}}" "#; let value: Value = toml::from_str(data).unwrap(); - info!("{value:?}"); let mut scope = Scope::new(); let err = scope.parse_asts(&value).unwrap_err(); @@ -268,20 +269,68 @@ mod tests { #[test] fn expression_bracket_error() { let data = r#" - joe = "{{joe bob {{ bill}}" + joe = "{{joe.bob {{ bill}}" "#; - let value: std::result::Result = toml::from_str(data); - let err = value.unwrap_err(); - info!("err: {err:?}") + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + assert_eq!("{{joe.bob {{ bill", val); + assert!(message.contains("unexpected `{{`")); } #[test] fn expression_bracket_error_2() { let data = r#" - joe = "{{joe bob bill}} bob fob}}" + joe = "{{joe.bob.bill}} bob.fob}}" + "#; + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + assert_eq!(r#" "{{joe.bob.bill}} bob.fob}}""#, val); + assert!(message.contains("unexpected `}}`")); + } + + #[test] + fn expression_bracket_error_3() { + let data = r#" + joe = "joe.bob.bill bob.fob}}" "#; - let value: std::result::Result = toml::from_str(data); - let err = value.unwrap_err(); - info!("err: {err:?}") + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + assert_eq!(r#" "joe.bob.bill bob.fob}}""#, val); + assert!(message.contains("unexpected `}}`")); + } + + #[test] + fn expression_bracket_error_4() { + let data = r#" + joe = "{{joe.bob.{{bill bob}}.fob}}" + "#; + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + assert_eq!(r#"{{joe.bob.{{bill bob"#, val); + assert!(message.contains("unexpected `")); } } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 087bbfc5..ee7512ae 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -8,13 +8,14 @@ use regex::Regex; use rhai::Dynamic; use serde::{Deserialize, Serialize}; use smallvec::SmallVec; +use smallvec::smallvec; use std::collections::HashMap; use std::io::Write; use toml::Spanned; use crate::bind::UNKNOWN_RANGE; use crate::err; -use crate::error::{ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; +use crate::error::{Error, ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; // @@ -49,6 +50,8 @@ pub enum Value { #[derive(Deserialize, Serialize, Debug, Clone)] pub struct Expression { pub content: String, + #[serde(skip)] + pub error: Option, // parsing-time error that we want to report after deserializing pub span: Range, pub scope: SmallVec<[(String, BareValue); 8]>, } @@ -265,29 +268,66 @@ impl Value { fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match) -> Result { if let Some(parent_span) = maybe_parent_span { let r = m.range(); - let exp_span = (parent_span.start + r.start)..(parent_span.start + r.end); + let exp_span = (parent_span.start + r.start)..(parent_span.start + r.end + 1); let content: String = m.as_str().into(); + let mut error = None; if content.contains("{{") { - return Err(RawError::Static("unexpected `{{`")).with_range(&exp_span)?; + error = Some(Error { + error: RawError::Static("unexpected `{{`"), + contexts: smallvec![crate::error::Context::Range(exp_span.clone())], + }); } return Ok(Value::Exp(Expression { content, span: exp_span, + error, scope: SmallVec::new(), })); } else { let content: String = m.as_str().into(); + let mut error = None; if content.contains("{{") { - return Err(RawError::Static("unexpected `{{`"))?; + error = Some(Error { + error: RawError::Static("unexpected `{{`"), + contexts: smallvec![], + }); } return Ok(Value::Exp(Expression { content, span: UNKNOWN_RANGE, + error, scope: SmallVec::new(), })); } } +fn check_unmatched_braces(x: String, span: Option>) -> Value { + if x.contains("{{") { + let mut error: Error = RawError::Static("unexpected `{{`").into(); + if let Some(r) = span.clone() { + error.contexts.push(crate::error::Context::Range(r)); + }; + return Value::Exp(Expression { + content: x, + error: Some(error), + span: span.unwrap_or_else(|| UNKNOWN_RANGE), + scope: SmallVec::new(), + }); + } else if x.contains("}}") { + let mut error: Error = RawError::Static("unexpected `}}`").into(); + if let Some(r) = span.clone() { + error.contexts.push(crate::error::Context::Range(r.clone())); + }; + return Value::Exp(Expression { + content: x, + span: span.unwrap_or_else(|| UNKNOWN_RANGE), + error: Some(error), + scope: SmallVec::new(), + }); + } + return Value::String(x); +} + fn string_to_expression(x: String, span: Option>) -> Result { let exprs = EXPRESSION.captures_iter(&x); // there are multiple expressions interpolated into the string @@ -311,25 +351,10 @@ fn string_to_expression(x: String, span: Option>) -> Result )?); } if last_match.start == 0 && last_match.end == 0 { - if x.contains("{{") { - let result = Err(RawError::Static("unexpected `{{`")); - if let Some(r) = span { - return result.with_range(&r); - } else { - result?; - } - } else if x.contains("}}") { - let result = Err(RawError::Static("unexpected `}}`")); - if let Some(r) = span { - return result.with_range(&r); - } else { - result?; - } - } - return Ok(Value::String(x)); + return Ok(check_unmatched_braces(x, span)); } if last_match.end < x.len() { - interps.push(Value::String(x[last_match.end..].into())); + interps.push(check_unmatched_braces(x[last_match.end..].into(), span)); } return Ok(Value::Interp(interps)); } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 954aab0b..8bbebba4 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -283,6 +283,7 @@ mod tests { Value::Exp(Expression { content: "val.foo_string".into(), span: UNKNOWN_RANGE, + error: None, scope: SmallVec::new(), }) ), @@ -331,6 +332,7 @@ mod tests { Value::Exp(Expression { content: "val.foo_string".into(), span: UNKNOWN_RANGE, + error: None, scope: SmallVec::new(), }) ), From 2b11a48c7ded8cd2bfeff4c227f359de3c27eabb Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 25 Sep 2025 19:04:23 -0400 Subject: [PATCH 56/79] `foreach` supports expression evaluation, `define.val` works at readtime Created using spr 1.3.6-beta.1 --- notes.md | 14 ++- src/rust/parsing/src/bind.rs | 118 ++++++++++++----------- src/rust/parsing/src/bind/command.rs | 21 ++-- src/rust/parsing/src/bind/foreach.rs | 61 ++++++------ src/rust/parsing/src/bind/validation.rs | 4 +- src/rust/parsing/src/define.rs | 15 +-- src/rust/parsing/src/error.rs | 2 + src/rust/parsing/src/expression.rs | 13 ++- src/rust/parsing/src/expression/value.rs | 66 +++++++++---- src/rust/parsing/src/file.rs | 67 +++++++++---- src/rust/parsing/src/util.rs | 41 ++++---- 11 files changed, 265 insertions(+), 157 deletions(-) diff --git a/notes.md b/notes.md index d3aa88b1..93b3ee96 100644 --- a/notes.md +++ b/notes.md @@ -184,11 +184,15 @@ Integration test debugging: - need to defer these errors until we run parse_asts so that we can get proper span information without having to pass errors through a deserialization object - - [ ] support expressions in `foreach` resolution - - [ ] add foreach variables to a local scope object - - [ ] add this local scope when the expression is `resolve!`ed - - [ ] allow for `var` evaluation in parse-time expressions + - [X] support expressions in `foreach` resolution + - [X] add foreach variables to a local scope object + - [X] expand expressions prior to resolving + - [X] unit tests + - [X] allow for `var` evaluation in parse-time expressions + - [X] implement + - [X] unit tests - [ ] implement support for `all` functions: + - [ ] implement lazy resolution of `all` values - [ ] `{{all_prefixes()}}` - [ ] `{{all_modes()}}` - [ ] `{{all_modes_but(["not_me", "or_me"])}}` @@ -219,6 +223,8 @@ Integration test debugging: - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause - [ ] re-implement master-key.do + - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make + sense) - [ ] move all bare variables in an expression to `key.` or `code.` object - [ ] transfer scope state from TS to rust Scope object - [ ] properly handle command queues (no controlled by rust) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 65a0084c..141f30ad 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -10,7 +10,7 @@ use toml::Spanned; use wasm_bindgen::prelude::*; pub mod command; -mod foreach; +pub mod foreach; pub mod validation; use crate::bind::command::{Command, regularize_commands}; @@ -509,9 +509,9 @@ impl Expanding for BindingDocInput { } impl Resolving for Option { - fn resolve(self, _name: &'static str) -> ResultVec { + fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { match self { - Some(doc) => Ok(BindingDoc::new(doc)?), + Some(doc) => Ok(BindingDoc::new(doc, scope)?), None => Ok(BindingDoc::default()), } } @@ -540,10 +540,10 @@ pub struct Binding { #[wasm_bindgen] impl Binding { pub fn repeat(&mut self, scope: &mut Scope) -> ResultVec { - return scope.expand(&self.repeat)?.resolve("`repeat`"); + return scope.expand(&self.repeat)?.resolve("`repeat`", scope); } - pub(crate) fn new(input: BindingInput) -> ResultVec { + pub(crate) fn new(input: BindingInput, scope: &mut Scope) -> ResultVec { if let Some(_) = input.id { return Err(err("`id` field is reserved"))?; } @@ -551,21 +551,24 @@ impl Binding { if let Some(_) = input.foreach { return Err(err("`foreach` included unresolved variables"))?; } - let commands = regularize_commands(&input)?; + let commands = regularize_commands(&input, scope)?; + + // TODO: this is where we need to expand any fields that + // have read-time expressions // TODO this is where we should validate that prefix has `finalKey == false` return Ok(Binding { commands: commands, - key: resolve!(input, key)?, - when: resolve!(input, when)?, - mode: resolve!(input, mode)?, - priority: resolve!(input, priority)?, - prefixes: resolve!(input, prefixes)?, - finalKey: resolve!(input, finalKey)?, - repeat: resolve!(input, repeat)?, - tags: resolve!(input, tags)?, - doc: resolve!(input, doc)?, + key: resolve!(input, key, scope)?, + when: resolve!(input, when, scope)?, + mode: resolve!(input, mode, scope)?, + priority: resolve!(input, priority, scope)?, + prefixes: resolve!(input, prefixes, scope)?, + finalKey: resolve!(input, finalKey, scope)?, + repeat: resolve!(input, repeat, scope)?, + tags: resolve!(input, tags, scope)?, + doc: resolve!(input, doc, scope)?, }); } } @@ -590,16 +593,16 @@ pub struct BindingDoc { #[wasm_bindgen] impl BindingDoc { - pub(crate) fn new(input: BindingDocInput) -> ResultVec { + pub(crate) fn new(input: BindingDocInput, scope: &mut Scope) -> ResultVec { return Ok(BindingDoc { - name: resolve!(input, name)?, - description: resolve!(input, description)?, - hideInPalette: resolve!(input, hideInPalette)?, - hideInDocs: resolve!(input, hideInDocs)?, - combinedName: resolve!(input, combinedName)?, - combinedKey: resolve!(input, combinedKey)?, - combinedDescription: resolve!(input, combinedDescription)?, - kind: resolve!(input, kind)?, + name: resolve!(input, name, scope)?, + description: resolve!(input, description, scope)?, + hideInPalette: resolve!(input, hideInPalette, scope)?, + hideInDocs: resolve!(input, hideInDocs, scope)?, + combinedName: resolve!(input, combinedName, scope)?, + combinedKey: resolve!(input, combinedKey, scope)?, + combinedDescription: resolve!(input, combinedDescription, scope)?, + kind: resolve!(input, kind, scope)?, }); } } @@ -642,6 +645,7 @@ mod tests { "#; let result = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); assert_eq!( String::from(result.command.into_inner().unwrap()), @@ -660,7 +664,7 @@ mod tests { assert_eq!(key, "a".to_string()); let when: String = result.when.unwrap().into_inner().into(); assert_eq!(when, "joe > 1".to_string()); - let mode: Vec = resolve!(result, mode).unwrap(); + let mode: Vec = resolve!(result, mode, &mut scope).unwrap(); assert_eq!(mode, ["normal"]); let priority: f64 = result.priority.unwrap().into_inner().into(); @@ -678,41 +682,38 @@ mod tests { ); assert_eq!(when, "joe > 1".to_string()); - let prefixes: Vec = resolve!(result, prefixes).unwrap(); + let prefixes: Vec = resolve!(result, prefixes, &mut scope).unwrap(); assert_eq!(prefixes, ["c"]); - let finalKey: bool = resolve!(result, finalKey).unwrap(); + let finalKey: bool = resolve!(result, finalKey, &mut scope).unwrap(); assert_eq!(finalKey, true); - let tags: Vec = resolve!(result, tags).unwrap(); + let tags: Vec = resolve!(result, tags, &mut scope).unwrap(); assert_eq!(tags, ["foo".to_string(), "bar".to_string()]); let doc = result.doc.unwrap(); - let name: String = resolve!(doc, name).unwrap(); + let name: String = resolve!(doc, name, &mut scope).unwrap(); assert_eq!(name, "foo"); - let description: String = doc.description.resolve("`description`").unwrap(); + let description: String = resolve!(doc, description, &mut scope).unwrap(); assert_eq!(description, "foo bar bin"); - let hideInDocs: bool = doc.hideInDocs.resolve("`hideInDocs`").unwrap(); + let hideInDocs: bool = resolve!(doc, hideInDocs, &mut scope).unwrap(); assert_eq!(hideInDocs, false); - let hideInPalette: bool = doc.hideInPalette.resolve("`hideInPalette`").unwrap(); + let hideInPalette: bool = resolve!(doc, hideInPalette, &mut scope).unwrap(); assert_eq!(hideInPalette, false); - let combinedName: String = doc.combinedName.resolve("`combinedName`").unwrap(); + let combinedName: String = resolve!(doc, combinedName, &mut scope).unwrap(); assert_eq!(combinedName, "Up/down"); - let combinedKey: String = doc.combinedKey.resolve("`combinedKey`").unwrap(); + let combinedKey: String = resolve!(doc, combinedKey, &mut scope).unwrap(); assert_eq!(combinedKey, "A/B"); - let combinedDescription: String = doc - .combinedDescription - .resolve("`combinedDescription`") - .unwrap(); + let combinedDescription: String = resolve!(doc, combinedDescription, &mut scope).unwrap(); assert_eq!(combinedDescription, "bla bla bla"); - let kind: String = resolve!(doc, kind).unwrap(); + let kind: String = resolve!(doc, kind, &mut scope).unwrap(); assert_eq!(kind, "biz"); } @@ -725,6 +726,7 @@ mod tests { "#; let result = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); assert_eq!( String::from(result.key.into_inner().unwrap()), "l".to_string() @@ -738,9 +740,9 @@ mod tests { Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); - let modes: Vec = resolve!(result, mode).unwrap(); + let modes: Vec = resolve!(result, mode, &mut scope).unwrap(); assert_eq!(modes.first().unwrap(), &"default".to_string()); - let when: Option = resolve!(result, when).unwrap(); + let when: Option = resolve!(result, when, &mut scope).unwrap(); assert_eq!(when, None); } @@ -760,11 +762,12 @@ mod tests { "#; let result = toml::from_str::>>(data).unwrap(); + let mut scope = Scope::new(); let default = result.get("bind").unwrap()[0].clone(); let left = result.get("bind").unwrap()[1].clone(); let left = default.merge(left); - let key: String = resolve!(left, key).unwrap(); + let key: String = resolve!(left, key, &mut scope).unwrap(); assert_eq!(key, "l".to_string()); assert_eq!( String::from(left.command.into_inner().unwrap()), @@ -776,13 +779,13 @@ mod tests { Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); - let prefixes: Vec = resolve!(left, prefixes).unwrap(); + let prefixes: Vec = resolve!(left, prefixes, &mut scope).unwrap(); assert_eq!(prefixes, ["b".to_string(), "c".to_string()]); let doc = left.doc.unwrap(); - let description: Option = resolve!(doc, combinedDescription).unwrap(); + let description: Option = resolve!(doc, combinedDescription, &mut scope).unwrap(); assert_eq!(description, None); - let name: Option = resolve!(doc, combinedName).unwrap(); + let name: Option = resolve!(doc, combinedName, &mut scope).unwrap(); assert_eq!(name, None); } @@ -870,26 +873,28 @@ mod tests { let data = r#" foreach.a = [1, 2] foreach.b = ["x", "y"] - doc.name = "test {{a}}-{{b}}" + doc.name = 'test {{a+1}}-{{b + "z"}}' command = "run-{{a}}" args.value = "with-{{b}}" "#; let result = toml::from_str::(data).unwrap(); - let items = result.expand_foreach().unwrap(); + let mut scope = Scope::new(); + scope.parse_asts(&result).unwrap(); + let items = result.expand_foreach(&mut scope).unwrap(); let expected_command = vec!["run-1", "run-1", "run-2", "run-2"]; let expected_value = vec!["with-x", "with-y", "with-x", "with-y"]; - let expected_name = vec!["test 1-x", "test 1-y", "test 2-x", "test 2-y"]; + let expected_name = vec!["test 2-xz", "test 2-yz", "test 3-xz", "test 3-yz"]; for i in 0..4 { let item = items[i].clone(); - let command: String = resolve!(item, command).unwrap(); + let command: String = resolve!(item, command, &mut scope).unwrap(); assert_eq!(command, expected_command[i]); - let name: String = resolve!(item.doc.unwrap(), name).unwrap(); + let name: String = resolve!(item.doc.unwrap(), name, &mut scope).unwrap(); assert_eq!(name, expected_name[i]); - let args: Option = resolve!(item, args).unwrap(); + let args: Option = resolve!(item, args, &mut scope).unwrap(); let mut expected_args = toml::Table::new(); expected_args.insert( "value".to_string(), @@ -909,7 +914,9 @@ mod tests { "#; let result = toml::from_str::(data).unwrap(); - let items = result.expand_foreach().unwrap(); + let mut scope = Scope::new(); + scope.parse_asts(&result).unwrap(); + let items = result.expand_foreach(&mut scope).unwrap(); let expected_name: Vec = (0..9).into_iter().map(|n| format!("update {n}")).collect(); @@ -917,9 +924,9 @@ mod tests { assert_eq!(items.len(), 10); for i in 0..9 { - let name: String = resolve!(items[i].doc.clone().unwrap(), name).unwrap(); + let name: String = resolve!(items[i].doc.clone().unwrap(), name, &mut scope).unwrap(); assert_eq!(name, expected_name[i]); - let value: Option = resolve!(items[i].clone(), args).unwrap(); + let value: Option = resolve!(items[i].clone(), args, &mut scope).unwrap(); let mut table = toml::Table::new(); table.insert( "value".to_string(), @@ -942,7 +949,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); scope.parse_asts(&input).unwrap(); - let result = Binding::new(input).unwrap(); + let result = Binding::new(input, &mut scope).unwrap(); + scope.state.set_or_push("joe", Dynamic::from("fiz")); let flat_args = result.commands[0].toml_args(&mut scope).unwrap(); diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 13d12efa..b274c833 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -15,7 +15,7 @@ use crate::{ value::{Expanding, Expression, TypedValue, Value}, }, resolve, - util::{Required, Resolving}, + util::Required, }; /// @forBindingField bind @order 15 @@ -115,8 +115,11 @@ impl From for Value { } } -pub(crate) fn regularize_commands(input: &BindingInput) -> ResultVec> { - let command: String = input.clone().command.resolve("`command`")?; +pub(crate) fn regularize_commands( + input: &BindingInput, + scope: &mut Scope, +) -> ResultVec> { + let command: String = resolve!(input.clone(), command, scope)?; if command != "runCommands" { let commands = vec![Command { command, @@ -232,17 +235,17 @@ impl Command { } impl Command { - pub fn new(input: CommandInput) -> ResultVec { + pub fn new(input: CommandInput, scope: &mut Scope) -> ResultVec { if let Some(_) = input.id { return Err(err("`id` fields is reserved"))?; } return Ok(Command { - command: resolve!(input, command)?, + command: resolve!(input, command, scope)?, args: match input.args { Some(x) => x.into_inner(), None => Value::Table(HashMap::new()), }, - skipWhen: resolve!(input, skipWhen)?, + skipWhen: resolve!(input, skipWhen, scope)?, }); } } @@ -272,8 +275,9 @@ mod tests { skipWhen = "{{count > 2}}" "#; + let mut scope = Scope::new(); let bind = toml::from_str::(data).unwrap(); - let commands = regularize_commands(&bind).unwrap(); + let commands = regularize_commands(&bind, &mut scope).unwrap(); assert_eq!(commands[0].command, "a"); assert_eq!(commands[1].command, "b"); @@ -318,7 +322,8 @@ mod tests { "#; let bind = toml::from_str::(data).unwrap(); - let commands = regularize_commands(&bind).unwrap_err(); + let mut scope = Scope::new(); + let commands = regularize_commands(&bind, &mut scope).unwrap_err(); let msg = match commands.errors[0].error { crate::error::RawError::Static(x) => x, _ => { diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 37948a4e..12ce7681 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -35,15 +35,17 @@ /// ``` use crate::bind::BindingInput; +use indexmap::IndexMap; use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; -use indexmap::IndexMap; +use rhai::{EvalAltResult, ImmutableString}; use toml::Spanned; -use crate::error::{ErrorContext, Result, ResultVec}; -use crate::expression::value::{Expanding, Expression, Value}; +use crate::error::{ErrorContext, ResultVec, flatten_errors}; +use crate::expression::Scope; +use crate::expression::value::{Expanding, Value}; const ALL_KEYS: [&'static str; 192] = [ "f0", @@ -245,27 +247,30 @@ lazy_static! { // static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); } -fn expand_keys_str(val: Expression) -> Result { - let c = KEY_PATTERN_REGEX.captures(&val.content); - if let Some(caps) = c { - let key_regex = Regex::new(&caps[1])?; - let mut result = Vec::new(); - for key in ALL_KEYS { - if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { - result.push(Value::String(key.into())); - } +pub fn expression_fn__keys( + val: ImmutableString, +) -> std::result::Result> { + let key_regex = match Regex::new(&val) { + Err(e) => { + return Err(e.to_string().into()); + } + Ok(x) => x, + }; + let mut result = rhai::Array::new(); + for key in ALL_KEYS { + if key_regex.find(key).is_some_and(|m| m.len() == key.len()) { + result.push(ImmutableString::from(key).into()) } - return Ok(Value::Array(result)); - } else { - return Ok(Value::Exp(val)); } + return Ok(result); } pub fn expand_keys( items: IndexMap>>, + scope: &mut Scope, ) -> ResultVec>> { // expand any `{{key(`regex`)}}` expressions (these are arrays of possible keys) - let items = items.map_expressions(&mut expand_keys_str)?; + let items = scope.expand(&items)?; // flatten any arrays return Ok(items @@ -291,27 +296,27 @@ impl BindingInput { return false; } - pub fn expand_foreach(self) -> ResultVec> { + pub fn expand_foreach(self, scope: &mut Scope) -> ResultVec> { if self.has_foreach() { - let foreach = expand_keys(self.foreach.clone().unwrap())?; + let foreach = expand_keys(self.foreach.clone().unwrap(), scope)?; foreach.require_constant().with_message( "`foreach` values can only include expressions of the form {{keys(`regex`)}}", )?; let values = expand_foreach_values(foreach).into_iter().map(|values| { - // TODO: this is where we will eventually add the `for` variables - // to the expression scope instead of inserting the values directly let mut result = self.clone(); result.foreach = None; - result - .map_expressions(&mut |x| { - Ok(values - .get(&x.content) - .map_or_else(|| Value::Exp(x), |ex| ex.clone())) - }) - .expect("no errors") // since our mapping function has no errors + result.map_expressions(&mut |mut expr| { + if let Some(e) = expr.error { + return Err(e.into()); + } + for (k, v) in values.clone() { + expr.scope.push((k, v.into())); + } + Ok(Value::Exp(expr)) + }) }); - return Ok(values.collect()); + return Ok(flatten_errors(values)?); } return Ok(vec![self]); } diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index fe0fd862..8fb0e1c9 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -6,6 +6,7 @@ use regex::Regex; use serde::{Deserialize, Serialize}; use crate::error::{ErrorSet, Result, ResultVec, err}; +use crate::expression::Scope; use crate::expression::value::{EXPRESSION, Expanding, Expression, TypedValue, Value}; use crate::util::{Merging, Resolving}; @@ -136,7 +137,8 @@ impl TryFrom for KeyBinding { } impl Resolving for KeyBinding { - fn resolve(self, _name: &'static str) -> ResultVec { + fn resolve(mut self, _name: &'static str, scope: &mut Scope) -> ResultVec { + self = scope.expand(&self)?; self.require_constant()?; Ok(self.into()) } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index cb15ccfa..d5cc6f6a 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -185,7 +185,7 @@ lazy_static! { } impl Define { - pub fn new(input: DefineInput) -> ResultVec { + pub fn new(input: DefineInput, scope: &mut Scope) -> ResultVec { let mut resolved_bind = HashMap::::new(); let mut resolved_command = HashMap::::new(); let mut resolved_var = HashMap::::new(); @@ -193,7 +193,7 @@ impl Define { for def_block in input.val.into_iter().flatten() { for (val, value) in def_block.into_iter() { - match value.resolve("`{val}` definition") { + match value.resolve("`define.val`", scope) { Ok(x) => { resolved_var.insert(val, x); } @@ -211,7 +211,7 @@ impl Define { .with_range(&def.span()); match span { Err(e) => errors.push(e.into()), - Ok(x) => match x.resolve("requires `id`") { + Ok(x) => match x.resolve("`id`", scope) { Err(mut e) => { errors.append(&mut e.errors); } @@ -229,7 +229,7 @@ impl Define { .with_range(&def.span()); match span { Err(e) => errors.push(e.into()), - Ok(x) => match x.resolve("`id`") { + Ok(x) => match x.resolve("`id`", scope) { Err(mut e) => { errors.append(&mut e.errors); } @@ -311,6 +311,8 @@ impl Define { mod tests { #[allow(unused_imports)] use super::*; + #[allow(unused_imports)] + use crate::resolve; #[test] fn simple_parsing() { @@ -334,7 +336,8 @@ mod tests { "#; - let result = Define::new(toml::from_str::(data).unwrap()).unwrap(); + let mut scope = Scope::new(); + let result = Define::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!(result.val.get("y").unwrap(), &Value::String("bill".into())); assert_eq!(result.val.get("joe").unwrap(), &Value::String("bob".into())); @@ -350,7 +353,7 @@ mod tests { ); let foobar = result.command.get("foobar").unwrap(); - let command: String = foobar.command.clone().resolve("`command`").unwrap(); + let command: String = resolve!(foobar.clone(), command, &mut scope).unwrap(); assert_eq!(command, "runCommands"); let commands = foobar.args.as_ref().unwrap().clone().into_inner(); assert_eq!( diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index c4fd1e21..975f8b67 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -20,6 +20,8 @@ use crate::bind::UNKNOWN_RANGE; #[derive(Debug, Error, Clone)] pub enum RawError { + #[error("conversion error: {0}")] + IntError(#[from] std::num::TryFromIntError), #[error("while parsing toml: {0}")] TomlParsing(#[from] toml::de::Error), #[error("while parsing expression: {0}")] diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 8ce61ced..1a559cfd 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -12,8 +12,8 @@ use serde::Serialize; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ - bind::command::Command, err, error::ErrorContext, error::Result, error::ResultVec, - expression::value::Expanding, expression::value::Value, + bind::command::Command, bind::foreach::expression_fn__keys, err, error::ErrorContext, + error::Result, error::ResultVec, expression::value::Expanding, expression::value::Value, }; /// @file expressions/index.md @@ -140,7 +140,14 @@ impl Scope { } return Ok(obj.clone().map_expressions(&mut |expr| { let ast = &self.asts[&expr.content]; + + let rewind_to = self.state.len(); + for (k, v) in &expr.scope { + let val: Dynamic = From::::from(Value::new(v.clone(), None)?); + self.state.push_dynamic(k, val); + } let dynamic: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; + self.state.rewind(rewind_to); let result_value: std::result::Result = dynamic.clone().try_into(); let value = result_value.with_message(format!(" while evaluating:\n{expr}"))?; return Ok(value); @@ -167,6 +174,7 @@ impl Scope { let mut engine = rhai::Engine::new(); engine.set_allow_looping(false); engine.set_allow_statement_expression(false); + engine.register_fn("keys", expression_fn__keys); return Scope { asts: HashMap::new(), @@ -227,6 +235,7 @@ impl Scope { } mod tests { + #[allow(unused_imports)] use super::*; use test_log::test; diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index ee7512ae..fbccbf68 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -16,6 +16,7 @@ use toml::Spanned; use crate::bind::UNKNOWN_RANGE; use crate::err; use crate::error::{Error, ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; +use crate::expression::Scope; use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; // @@ -23,7 +24,7 @@ use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; // /// `Value` is an expressive type that can be used to represent any TOML / JSON object with -/// one more expressions in them. Crucially, it implements the `Expanding` trait, which +/// one or more expressions in them. Crucially, it implements the `Expanding` trait, which /// allows those expressions to be expanded into `Value`'s themselves. Values are used /// to represent parsed TOML data, expand the expressions in them, and translate /// those values to JSON and/or Rhai `Dynaamic` objects. @@ -241,7 +242,7 @@ lazy_static! { } impl Value { - fn new(value: BareValue, range: Option>) -> Result { + pub fn new(value: BareValue, range: Option>) -> Result { return Ok(match value { BareValue::Boolean(x) => Value::Boolean(x), BareValue::Float(x) => Value::Float(x), @@ -419,6 +420,32 @@ impl TryFrom for BareValue { } } +impl From for BareValue { + fn from(value: Value) -> BareValue { + return match value { + Value::Exp(Expression { content: x, .. }) => panic!("Unresolved expression {x}"), + Value::Interp(interps) => { + panic!("Unresolved interpolation {}", interp_to_string(interps)) + } + Value::Array(items) => { + let new_items = items.into_iter().map(|it| it.into()).collect(); + BareValue::Array(new_items) + } + Value::Table(kv) => { + let new_kv = kv + .into_iter() + .map(|(k, v)| (k, Spanned::new(UNKNOWN_RANGE, v.into()))) + .collect(); + BareValue::Table(new_kv) + } + Value::Boolean(x) => BareValue::Boolean(x), + Value::Float(x) => BareValue::Float(x), + Value::Integer(x) => BareValue::Integer(x), + Value::String(x) => BareValue::String(x), + }; + } +} + impl From for toml::Value { fn from(value: Value) -> toml::Value { return match value { @@ -446,7 +473,7 @@ impl From for Dynamic { fn from(value: Value) -> Self { return match value { Value::Float(x) => Dynamic::from(x), - Value::Integer(x) => Dynamic::from(x), + Value::Integer(x) => Dynamic::from(x as i64), Value::Boolean(x) => Dynamic::from(x), Value::String(x) => Dynamic::from(x), Value::Array(x) => { @@ -470,7 +497,9 @@ impl TryFrom for Value { // TODO: this is currently almost certainly quite inefficient (we clone arrays and // maps), but we can worry about optimizing this later fn try_from(value: Dynamic) -> Result { - if value.is_array() { + if value.is::() { + return Ok(value.cast::()); + } else if value.is_array() { let elements = value.as_array_ref().expect("array value"); let values = elements .clone() @@ -491,7 +520,11 @@ impl TryFrom for Value { } else if value.is_float() { return Ok(Value::Float(value.as_float().expect("float"))); } else if value.is_int() { - return Ok(Value::Integer(value.as_int().expect("integer") as i32)); + return Ok(Value::Integer(i32::try_from( + value.as_int().expect("integer"), + )?)); + } else if value.is::() { + return Ok(Value::Integer(value.cast::())); } else if value.is_string() { return Ok(Value::String( value @@ -549,18 +582,16 @@ impl Merging for Value { } impl Resolving for Value { - fn resolve(self, _name: &'static str) -> ResultVec { + fn resolve(self, _name: &'static str, _scope: &mut Scope) -> ResultVec { Ok(self) } } impl Resolving for Value { - fn resolve(self, name: &'static str) -> ResultVec { - // TODO: this is where we will eventually evaluate expressions - // *wihtin* their scope + fn resolve(mut self, name: &'static str, scope: &mut Scope) -> ResultVec { + self = scope.expand(&self)?; self.require_constant() - .with_message("for ") - .with_message(name)?; + .with_message(format!(" for {}", name))?; return Ok(self.into()); } } @@ -914,12 +945,12 @@ where T: Serialize + std::fmt::Debug + Resolving, TypedValue: Expanding + Clone + Into, { - fn resolve(self, name: &'static str) -> ResultVec { + fn resolve(mut self, name: &'static str, scope: &mut Scope) -> ResultVec { + self = scope.expand(&self)?; self.require_constant() - .with_message("for ") - .with_message(name)?; + .with_message(format!("for `{name}`"))?; let constant = self.into(); - return constant.resolve(name); + return constant.resolve(name, scope); } } @@ -927,7 +958,7 @@ impl Resolving> for TypedValue where T: LeafValue + Serialize + std::fmt::Debug, { - fn resolve(self, _name: &'static str) -> ResultVec> { + fn resolve(self, _name: &'static str, _scope: &mut Scope) -> ResultVec> { return Ok(self); } } @@ -936,7 +967,7 @@ impl Resolving> for Option>> where T: Default + Serialize + std::fmt::Debug, { - fn resolve(self, _name: &'static str) -> ResultVec> { + fn resolve(self, _name: &'static str, _scope: &mut Scope) -> ResultVec> { return match self { Some(x) => Ok(x.into_inner()), Option::None => Ok(TypedValue::default()), @@ -955,6 +986,7 @@ impl Merging for TypedValue { } mod tests { + #[allow(unused_imports)] use super::*; #[test] diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 8bbebba4..811e1513 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -102,19 +102,20 @@ struct KeyFileInput { } #[derive(Clone, Debug, Serialize)] -#[allow(non_snake_case)] -#[wasm_bindgen(getter_with_clone)] +#[wasm_bindgen] pub struct KeyFile { define: Define, - pub bind: Vec, + bind: Vec, } +// TODO: implement methods to access/store bindings + impl KeyFile { - fn new(input: KeyFileInput) -> ResultVec { + fn new(input: KeyFileInput, mut scope: &mut Scope) -> ResultVec { // [[define]] let mut errors = Vec::new(); let define_input = input.define.unwrap_or_default(); - let mut define = match Define::new(define_input) { + let mut define = match Define::new(define_input, &mut scope) { Err(mut es) => { errors.append(&mut es.errors); Define::default() @@ -137,7 +138,6 @@ impl KeyFile { Ok(x) => x, }; - let mut scope = Scope::new(); define.add_to_scope(&mut scope)?; let _ = scope .parse_asts(&bind_input) @@ -147,7 +147,7 @@ impl KeyFile { .into_iter() .flat_map(|x| { let span = x.span().clone(); - match x.into_inner().expand_foreach() { + match x.into_inner().expand_foreach(&mut scope) { Ok(replicates) => { // we resolve the foreach elements originating from a single item // here, rather than expanding and flattening all errors across @@ -158,7 +158,7 @@ impl KeyFile { // required `key` field` to show up three times let items = replicates .into_iter() - .map(Binding::new) + .map(|x| Binding::new(x, &mut scope)) .collect::>>() .with_range(&span); match items { @@ -185,6 +185,7 @@ impl KeyFile { } } +// TODO: don't use clone on `file` #[wasm_bindgen(getter_with_clone)] pub struct KeyFileResult { pub file: Option, @@ -207,7 +208,8 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { let parsed = toml::from_slice::(file_content)?; - return KeyFile::new(parsed); + let mut scope = Scope::new(); // TODO: do something with this scope?? + return KeyFile::new(parsed, &mut scope); } #[cfg(test)] @@ -269,7 +271,9 @@ mod tests { key = "a" "#; - let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key, "a"); @@ -318,7 +322,9 @@ mod tests { key = "a" "#; - let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key, "a"); @@ -352,7 +358,9 @@ mod tests { args.value = "{{key}}" "#; - let result = KeyFile::new(toml::from_str::(data).unwrap()).unwrap(); + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); let expected_name: Vec = (0..9).into_iter().map(|n| format!("update {n}")).collect(); @@ -362,11 +370,15 @@ mod tests { for i in 0..9 { assert_eq!(result.bind[i].doc.name, expected_name[i]); assert_eq!( - result.bind[i].commands[0].args, - Value::Table(HashMap::from([( - "value".to_string(), - Value::String(expected_value[i].clone()) - ),])) + result.bind[i].commands[0].toml_args(&mut scope).unwrap(), + toml::Value::Table( + [( + "value".to_string(), + toml::Value::String(expected_value[i].clone()) + )] + .into_iter() + .collect() + ) ); } } @@ -382,13 +394,32 @@ mod tests { "#; // TODO: ensure that a proper span is shown here - let result = KeyFile::new(toml::from_str::(data).unwrap()); + let mut scope = Scope::new(); + let result = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope); let report = result.unwrap_err().report(data.as_bytes()); assert_eq!(report[0].message, "`key` field is required".to_string()); assert_eq!(report[0].range.start.line, 1); assert_eq!(report[0].range.end.line, 1); } + #[test] + fn define_val_at_read() { + let data = r#" + [[define.val]] + foo = "bar" + + [[bind]] + key = "x" + command = "{{foo}}" + args.val = 2 + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert_eq!(result.bind[0].commands[0].command, "bar"); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 4903326a..273975dd 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -8,6 +8,7 @@ use toml::{Spanned, Value}; use crate::err; use crate::error::{Error, ErrorContext, Result, ResultVec, flatten_errors}; +use crate::expression::Scope; // // ---------------- Merging ---------------- @@ -63,10 +64,12 @@ impl Merging for IndexMap { fn merge(self, new: Self) -> Self { let (mut to_merge, to_append): (IndexMap<_, _>, IndexMap<_, _>) = new.into_iter().partition(|(k, _)| self.get(k).is_some()); - let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { - Some(new_v) => (k, v.merge(new_v)), - Option::None => (k, v), - }); + let pairs = self + .into_iter() + .map(|(k, v)| match to_merge.shift_remove(&k) { + Some(new_v) => (k, v.merge(new_v)), + Option::None => (k, v), + }); return pairs.chain(to_append.into_iter()).collect(); } } @@ -206,8 +209,8 @@ impl Merging for toml::Value { #[macro_export] macro_rules! resolve { - ($x:expr, $field:ident) => { - crate::util::Resolving::resolve(($x).$field, stringify!($field)) + ($x:expr, $field:ident, $scope:expr) => { + crate::util::Resolving::resolve(($x).$field, stringify!($field), $scope) }; } @@ -216,7 +219,7 @@ macro_rules! resolve { /// representation useful for downstream operations that don't care about these /// book-keeping objects. pub trait Resolving { - fn resolve(self, name: &'static str) -> ResultVec; + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec; } pub(crate) trait LeafValue {} @@ -232,9 +235,9 @@ impl Resolving for Spanned where T: Resolving, { - fn resolve(self, name: &'static str) -> ResultVec { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec { let span = self.span(); - Ok(self.into_inner().resolve(name).with_range(&span)?) + Ok(self.into_inner().resolve(name, scope).with_range(&span)?) } } @@ -242,7 +245,7 @@ impl Resolving for T where T: LeafValue, { - fn resolve(self, _name: &'static str) -> ResultVec { + fn resolve(self, _name: &'static str, _scope: &mut Scope) -> ResultVec { return Ok(self); } } @@ -252,9 +255,9 @@ where T: Resolving, U: Default + LeafValue, { - fn resolve(self, name: &'static str) -> ResultVec { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec { match self { - Some(x) => x.resolve(name), + Some(x) => x.resolve(name, scope), Option::None => Ok(U::default()), } } @@ -264,9 +267,9 @@ impl Resolving> for Option where T: Resolving, { - fn resolve(self, name: &'static str) -> ResultVec> { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec> { match self { - Some(x) => Ok(Some(x.resolve(name)?)), + Some(x) => Ok(Some(x.resolve(name, scope)?)), Option::None => Ok(None), } } @@ -303,10 +306,10 @@ impl Resolving for Required where T: Resolving, { - fn resolve(self, name: &'static str) -> ResultVec { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec { match self { Required::DefaultValue => Err(err!("`{name}` field is required"))?, - Required::Value(x) => x.resolve(name), + Required::Value(x) => x.resolve(name, scope), } } } @@ -402,7 +405,9 @@ where T: Clone + Resolving + std::fmt::Debug, U: std::fmt::Debug, { - fn resolve(self, name: &'static str) -> ResultVec> { - Ok(flatten_errors(self.0.into_iter().map(|x| x.resolve(name)))?) + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec> { + Ok(flatten_errors( + self.0.into_iter().map(|x| x.resolve(name, scope)), + )?) } } From 3b440f80550c933d9c8bc1eed389b17a8fbe60d5 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 30 Sep 2025 09:23:32 -0400 Subject: [PATCH 57/79] working `[[mode]]` section Created using spr 1.3.6-beta.1 --- notes.md | 35 ++- src/presets/larkin.toml | 86 ++++--- src/rust/parsing/src/bind.rs | 83 ++++-- src/rust/parsing/src/bind/command.rs | 24 +- src/rust/parsing/src/bind/foreach.rs | 1 + src/rust/parsing/src/expression.rs | 10 +- src/rust/parsing/src/expression/value.rs | 14 +- src/rust/parsing/src/file.rs | 196 +++++++++++++- src/rust/parsing/src/lib.rs | 1 + src/rust/parsing/src/mode.rs | 312 +++++++++++++++++++++++ src/rust/parsing/src/util.rs | 16 ++ 11 files changed, 680 insertions(+), 98 deletions(-) create mode 100644 src/rust/parsing/src/mode.rs diff --git a/notes.md b/notes.md index 93b3ee96..8c62b286 100644 --- a/notes.md +++ b/notes.md @@ -159,7 +159,7 @@ Integration test debugging: - [X] remove all compile warnings - [X] implement support for tags on `bind` (for filter them) - [X] implement support for `skipWhen` in `command` - - [ ] improve expression evaluation + - [X] improve expression evaluation - [X] improve error reporting in expressions - [X] support spans for expressions - [X] create a `RawValue` that tracks spans @@ -191,11 +191,17 @@ Integration test debugging: - [X] allow for `var` evaluation in parse-time expressions - [X] implement - [X] unit tests - - [ ] implement support for `all` functions: - - [ ] implement lazy resolution of `all` values - - [ ] `{{all_prefixes()}}` - - [ ] `{{all_modes()}}` - - [ ] `{{all_modes_but(["not_me", "or_me"])}}` + - [X] implement `[[mode]]` + - [X] implement + - [X] add to `KeyFile` + - [X] validate mode in `[[bind]]` + - [X] add documentation + - [X] use `Option>` in BindingInput so we can + properly resolve to the default mode instead of "default" + - [X] get existing unit tests working + - [X] write test cases for error paths + - [X] write tests for expressions to specify modes + - [ ] move `combinedName` and friends to `combined.name` and friends - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls @@ -204,21 +210,34 @@ Integration test debugging: - [ ] validation that `master-key.prefix` uses `finalKey: false` - [ ] validation that keybindings with non modifier keybindings have a condition requiring textEditorFocus - - [ ] modes are all positive or negative + (or just insert it) - [ ] required keys are present - [ ] mode expansion: define a key binding per mode - [ ] key-sequence expansion and duplicate resolution: - [ ] create a binding per key in a sequence that requires a given prefix (depending on the prefix code of its prefix) - [ ] add any missing prefixes + - [ ] implement the `all` functions: + - [ ] `{{all_prefixes()}}` + - [ ] `{{all_prefixes_but()}}` + - [X] `{{all_modes()}}` + - [X] `{{all_modes_but(["not_me", "or_me"])}}` - [ ] documentation expandsion/validation across all `[[bind]]` values with the same key and mode e.g. merge all shared documentation across the shared names - [ ] find low hanging fruit for problems with using 1.0 files - - [ ] fields that exist in the old but not new (use #[serde(flatten)]) + - [ ] fields that exist in the old but not new (use `#[serde(flatten)]`) - [ ] add hints for fields that don't exist anywhere as well (probably as a hint or something) + - [ ] review strings for single `{}` braces and warn that `{{}}` are now required - [ ] others + - [ ] implement `[[kind]]` + - [ ] implement `[header]` section + - [ ] instead of using `.mk.toml`, look for a specific heading in the file + - [ ] remove spurious line/char positions from expression error messages + - NOTE: these come from the line and char position in the rhai expression + which has nothing to do with the line and char position in the parent + keybinding file - [ ] proper conversion to keybindings.json command - [ ] expand prefixes to prefixCode and move to when clause - [ ] move mode to when clause diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 6e7db669..22b0fab3 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -42,21 +42,21 @@ requiredExtensions = [ ] [[mode]] -doc.name = "insert" -recordEdits = true +name = "insert" +whenNoBinding = "insert" [[mode]] -doc.name = "normal" +name = "normal" default = true highlight = "Highlight" cursorShape = "Block" [[mode]] -doc.name = "selectedit" +name = "selectedit" highlight = "Highlight" cursorShape = "BlockOutline" -[[define.var]] +[[define.val]] select = false [[kind]] @@ -115,9 +115,11 @@ doc.name = "suggest" finalKey = false doc.hideInPalette = true prefixes = "{{all_prefixes()}}" -mode = '{{all_modes_but(["capture", "insert"]}}' +mode = '{{not_modes(["capture", "insert"]}}' doc.description = """ -show command suggestions within the context of the current mode and keybinding prefix (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that start with `TAB`. +show command suggestions within the context of the current mode and keybinding prefix +(if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that +start with `TAB`. """ command = "master-key.commandSuggestions" @@ -189,7 +191,7 @@ foreach.modifier = ["shift+", ""] key = "{{modifier}}{{key}}" command = "master-key.ignore" prefixes = "{{all_prefixes()}}" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' when = "editorTextFocus" doc.hideInDocs = true doc.hideInPalette = true @@ -222,7 +224,7 @@ id = "edit_motion_prim" default = "{{bind.edit_motion}}" command = "cursorMove" args.value = "{{count}}" -args.select = "{{editorHasSelection || var.select}}" +args.select = "{{editorHasSelection || val.select}}" [[bind]] default = "{{bind.edit_motion_prim}}" @@ -327,7 +329,7 @@ command = "expandLineSelection" [[bind]] default = "{{bind.edit_motion_prim}}" key = "ctrl+d" -mode = '{{all_modes_but(["normal", "insert"]}}' +mode = '{{not_modes(["normal", "insert"]}}' doc.name = "pg ↓" doc.combinedName = "pg ↓/↑" doc.combinedKey = "ctrl+d/ctrl+u" @@ -341,7 +343,7 @@ args.select = "{{mode == 'normal'}}" [[bind]] default = "{{bind.edit_motion_prim}}" key = "ctrl+u" -mode = '{{all_modes_but(["normal", "insert"]}}' +mode = '{{not_modes(["normal", "insert"]}}' doc.name = "pg ↑" doc.combinedName = "pg ↓/↑" doc.description = "move up, relative to page size" @@ -476,7 +478,7 @@ reduce all selections to length zero command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "var.select", value = false } }, + { command = "master-key.setFlag", args = { name = "{{val.select}}", value = false } }, ] [[bind]] @@ -488,7 +490,7 @@ doc.description = """ all motions extend the selection """ command = "master-key.setFlag" -args.doc.name = "var.select" +args.doc.name = "{{val.select}}" args.value = true [[bind]] @@ -547,7 +549,7 @@ doc.combinedName = "→/← sel" doc.description = "select *just* the character to the right" doc.combinedDescription = "select *just* the character to the right" doc.combinedKey = 'shift+\/\' -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' command = "runCommands" [[bind.args.commands]] @@ -563,7 +565,7 @@ key = 'shift+\' doc.name = "← sel" doc.combinedName = "→/← sel" doc.description = "select *just* the character to the left" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' command = "runCommands" [[bind.args.commands]] @@ -637,7 +639,7 @@ doc.combinedName = "count 0-9" doc.combinedDescription = "Add digit 1-9 to count argument of a command" args.value = "{{num}}" finalKey = false -mode = '{{all_modes_except(["insert", "capture"])}}' +mode = '{{not_modes(["insert", "capture"])}}' doc.hideInDocs = true # There are several ways to repeat or undo previously entered commands, both actions and motions @@ -1505,14 +1507,14 @@ doc.name = "insert" doc.description = "Switch to insert mode (right before character)" command = "runCommands" args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] -mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' +mode = '{{not_modes(["normal", "selectedit", "syminsert"]}}' [[bind]] default = "{{bind.edit_action}}" key = "a" doc.name = "append" doc.description = "insert after cursor" -mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' +mode = '{{not_modes(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", @@ -1524,7 +1526,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "shift+i" doc.name = "insert start" -mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' +mode = '{{not_modes(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ { command = "cursorMove", args = { to = "wrappedLineFirstNonWhitespaceCharacter", select = false } }, @@ -1535,7 +1537,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "shift+a" doc.name = "insert end" -mode = '{{all_modes_but(["normal", "selectedit", "syminsert"]}}' +mode = '{{not_modes(["normal", "selectedit", "syminsert"]}}' command = "runCommands" args.commands = [ { command = "cursorMove", args = { to = "wrappedLineEnd", select = false } }, @@ -1604,7 +1606,7 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+c" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' when = "master-key.count > 1" command = "runCommands" args.commands = [ @@ -1637,7 +1639,7 @@ command = "master-key.replaceChar" default = "{{bind.edit_action}}" key = "ctrl+i" doc.name = "insert char" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' doc.description = "insert a character in front of the cursor" command = "master-key.insertChar" @@ -1670,7 +1672,7 @@ args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] default = "{{bind.edit_action}}" key = "ctrl+p" when = "!suggestWidgetVisible" -mode = '{{all_modes_but(["normal", "insert"]}}' +mode = '{{not_modes(["normal", "insert"]}}' doc.name = "paste in" doc.combinedName = "paste before/after/in" doc.description = "Paste clipboard at location" @@ -1900,7 +1902,7 @@ command = "selection-utilities.decrementNumber" [[define.bind]] id = "edit_action_capitals" default = "{{bind.edit_action}}" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' [[bind]] default = "{{bind.edit_action_capitals}}" @@ -2079,8 +2081,8 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -args.before = "{{var.braces[captured].before || captured}}" -args.after = "{{var.braces[captured].after || captured}}" +args.before = "{{val.braces[captured].before || captured}}" +args.after = "{{val.braces[captured].after || captured}}" args.followCursor = true [[bind]] @@ -2106,7 +2108,7 @@ doc.name = 'join' doc.combinedName = "wrap/join lines" doc.description = "Remove newline between current and next line" key = "space j" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' when = "!editorHasSelection" command = "runCommands" args.commands = ["{{command.selectLinesDown}}", 'editor.action.joinLines'] @@ -2116,7 +2118,7 @@ default = "{{bind.edit_action}}" doc.combinedName = "wrap/join lines" doc.name = 'join' doc.description = "Remove newline between current and next line" -mode = '{{all_modes_but(["normal", "selectedit"]}}' +mode = '{{not_modes(["normal", "selectedit"]}}' key = "space j" command = "editor.action.joinLines" @@ -2546,14 +2548,14 @@ doc.combinedName = "mark ↓/↑" doc.combinedDescription = "move to next/previous bookmark" doc.combinedKey = "j/k" key = "tab m j" -when = "!master-key.var.select && !editorHasSelection" +when = "!master-key.val.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] default = "{{bind.util}}" doc.combinedName = "mark ↓/↑" key = "tab m j" -when = "master-key.var.select || editorHasSelection" +when = "master-key.val.select || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] @@ -2562,7 +2564,7 @@ doc.name = "mark ↑" doc.combinedName = "mark ↓/↑" doc.description = "move to previous bookmark" key = "tab m k" -when = "!master-key.var.select && !editorHasSelection" +when = "!master-key.val.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] @@ -2571,7 +2573,7 @@ doc.name = "mark ↑" doc.combinedName = "mark ↓/↑" doc.description = "move to previous bookmark" key = "tab m k" -when = "master-key.var.select || editorHasSelection" +when = "master-key.val.select || editorHasSelection" command = "runCommands" args.commands = [ "vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", @@ -2930,12 +2932,12 @@ doc.name = "del. cursors" doc.description = "Delete all selections and return to normal" command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] -mode = '{{all_modes_but(["selectedit", "normal"]}}' +mode = '{{not_modes(["selectedit", "normal"]}}' [[bind]] default = "{{bind.edit_select_edit}}" key = "ctrl+'" -mode = '{{all_modes_but(["insert", "selectedit", "normal"]}}' +mode = '{{not_modes(["insert", "selectedit", "normal"]}}' doc.name = "rm cursors" doc.combinedName = "rm cursors" doc.description = "Delete all selections and return to normal" @@ -3251,7 +3253,7 @@ command = "selection-utilities.activeAtStart" # As a general rule, the letter keys issue commands of various sorts, and the other keys can be used to enter text (since we rarley want to surround a selection with an `a` but might want to surround it with `*` or `/`. -[[define.var]] +[[define.val]] "{".before = "{" "{".after = "}" @@ -3274,14 +3276,14 @@ command = "selection-utilities.activeAtStart" ">".after = ">" [[mode]] -doc.name = "syminsert" +name = "syminsert" highlight = "Highlight" cursorShape = "BlockOutline" -[[mode.onType]] +[[mode.whenNoBinding.run]] command = "selection-utilities.insertAround" -args.before = "{{var.braces[captured].before || captured}}" -args.after = "{{var.braces[captured].after || captured}}" +args.before = "{{val.braces[captured].?before ?? captured}}" +args.after = "{{val.braces[captured].?after ?? captured}}" args.followCursor = true [[define.bind]] @@ -3341,8 +3343,8 @@ args.acceptAfter = 1 [[bind.args.commands]] command = "selection-utilities.insertAround" -args.before = "{{'\\\\' + (var.braces[captured].before || captured)}}" -args.after = "{{'\\\\' + (var.braces[captured].after || captured)}}" +args.before = "{{'\\\\' + (val.braces[captured].?before ?? captured)}}" +args.after = "{{'\\\\' + (val.braces[captured].?after ?? captured)}}" args.followCursor = true [[bind]] @@ -3416,6 +3418,6 @@ reduce all selections to length zero and return to normal mode command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "var.select", value = false } }, + { command = "master-key.setFlag", args = { name = "val.select", value = false } }, "master-key.enterNormal", ] diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 141f30ad..a772f84d 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -1,5 +1,3 @@ -#![allow(non_snake_case)] - #[allow(unused_imports)] use log::info; @@ -15,7 +13,8 @@ pub mod validation; use crate::bind::command::{Command, regularize_commands}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{Result, ResultVec, err}; +use crate::err; +use crate::error::{ErrorContext, Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; @@ -23,13 +22,6 @@ use crate::util::{Merging, Plural, Required, Resolving}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; -fn default_mode() -> Spanned>> { - return Spanned::new( - UNKNOWN_RANGE, - TypedValue::Constant(Plural(vec!["default".to_string()])), - ); -} - fn span_required_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Required::DefaultValue); } @@ -61,6 +53,7 @@ fn span_plural_default() -> Spanned>> { /// /// ## Fields /// +#[allow(non_snake_case)] #[derive(Deserialize, Clone, Debug)] pub struct BindingInput { // implementation detail of `BindingInput`: this field should only be `Some` when used @@ -88,7 +81,6 @@ pub struct BindingInput { /// /// - ⚡ `args`: The arguments to directly pass to `command`. Args may include /// runtime evaluated [expressions](/expressions/index). - #[serde(default)] pub args: Option>, /// @forBindingField bind @@ -105,21 +97,18 @@ pub struct BindingInput { /// that will be evaluated while the bindings are being parsed. There are two /// available functions of use here: /// [`all_modes`](/expressions/functions#all_modes) and - /// [`all_modes_but`](/expressions/functions#all_modes_but) - #[serde(default = "default_mode")] - pub mode: Spanned>>, + /// [`not_modes`](/expressions/functions#not_modes) + pub mode: Option>>>, /// @forBindingField bind /// /// - `priority`: The ordering of the keybinding relative to others; determines which /// bindings take precedence. Defaults to 0. - #[serde(default)] pub priority: Option>>, /// @forBindingField bind /// /// - `default`: the default values to use for fields, specified as /// string of the form `{{bind.[name]}}`. /// See [`define`](/bindings/define) for more details. - #[serde(default)] pub default: Option>, /// @forBindingField bind /// @@ -147,7 +136,6 @@ pub struct BindingInput { /// - `finalKey`: (boolean, default=true) Whether this key should clear any transient /// state associated with the pending keybinding prefix. See /// [`master-key.prefix`](/commands/prefix) for details. - #[serde(default)] pub finalKey: Option>>, /// @forBindingField bind @@ -316,7 +304,7 @@ impl Expanding for BindingInput { }), mode: self.mode.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, TypedValue::default()) + None }), priority: self.priority.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -359,6 +347,7 @@ impl Expanding for BindingInput { // ---------------- `bind.doc` parsing ---------------- // +#[allow(non_snake_case)] #[derive(Deserialize, Serialize, Clone, Debug)] pub struct BindingDocInput { /// @forBindingField bind @@ -512,7 +501,7 @@ impl Resolving for Option { fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { match self { Some(doc) => Ok(BindingDoc::new(doc, scope)?), - None => Ok(BindingDoc::default()), + Option::None => Ok(BindingDoc::default()), } } } @@ -553,23 +542,47 @@ impl Binding { } let commands = regularize_commands(&input, scope)?; - // TODO: this is where we need to expand any fields that - // have read-time expressions - // TODO this is where we should validate that prefix has `finalKey == false` - return Ok(Binding { + let mode_span = match input.mode { + Some(ref mode) => mode.span().clone(), + Option::None => UNKNOWN_RANGE, + }; + + let result = Binding { commands: commands, key: resolve!(input, key, scope)?, when: resolve!(input, when, scope)?, - mode: resolve!(input, mode, scope)?, + mode: match input.mode { + Option::None => vec![scope.default_mode.clone()], + Some(mode) => mode.clone().resolve("mode", scope)?, + }, priority: resolve!(input, priority, scope)?, prefixes: resolve!(input, prefixes, scope)?, finalKey: resolve!(input, finalKey, scope)?, repeat: resolve!(input, repeat, scope)?, tags: resolve!(input, tags, scope)?, doc: resolve!(input, doc, scope)?, - }); + }; + + let undefined_modes: Vec<_> = result + .mode + .iter() + .filter(|x| !scope.modes.contains(x.as_str())) + .collect(); + if undefined_modes.len() > 0 { + return Err(err!( + "Undefined mode(s): {}", + undefined_modes + .iter() + .map(|x| x.as_str()) + .collect::>() + .join(", ") + )) + .with_range(&mode_span)?; + } + + return Ok(result); } } @@ -611,6 +624,7 @@ impl BindingDoc { // ================ Tests ================ // +#[allow(non_snake_case)] #[cfg(test)] mod tests { use test_log::test; @@ -740,8 +754,6 @@ mod tests { Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); - let modes: Vec = resolve!(result, mode, &mut scope).unwrap(); - assert_eq!(modes.first().unwrap(), &"default".to_string()); let when: Option = resolve!(result, when, &mut scope).unwrap(); assert_eq!(when, None); } @@ -963,6 +975,23 @@ mod tests { assert_eq!(flat_args, toml::Value::Table(args_expected)); } + #[test] + fn mode_validation() { + let data = r#" + key = "a" + command = "foo" + mode = "bar" + "#; + + let input = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let err = Binding::new(input, &mut scope).unwrap_err(); + info!("err: {err}"); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("Undefined mode")); + assert_eq!(report[0].range.start.line, 3); + } + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index b274c833..316a55ce 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -15,10 +15,11 @@ use crate::{ value::{Expanding, Expression, TypedValue, Value}, }, resolve, - util::Required, + util::{Required, Resolving}, }; -/// @forBindingField bind @order 15 +/// @forBindingField bind +/// @order 15 /// /// ## Running Multiple Commands /// @@ -33,6 +34,7 @@ use crate::{ /// /// The object fields are defined as follows: /// +#[allow(non_snake_case)] #[derive(Deserialize, Clone, Debug)] pub struct CommandInput { // should only be `Some` in context of `Define(Input)` @@ -157,6 +159,7 @@ pub(crate) fn regularize_commands( let mut command_result = Vec::with_capacity(command_vec.len()); for command in command_vec { + #[allow(non_snake_case)] let (command, args, skipWhen) = match command { Value::String(str) => ( str.to_owned(), @@ -175,7 +178,7 @@ pub(crate) fn regularize_commands( } }; let result = match kv.get("args") { - None => &Value::Table(HashMap::new()), + Option::None => &Value::Table(HashMap::new()), Some(x) => x, }; let args = match result { @@ -187,7 +190,7 @@ pub(crate) fn regularize_commands( }; let result = match kv.get("skipWhen") { - None => Value::Boolean(false), + Option::None => Value::Boolean(false), Some(x) => x.clone(), }; let skipWhen: TypedValue = result.try_into()?; @@ -210,8 +213,9 @@ pub(crate) fn regularize_commands( } } +#[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] -#[derive(Clone, Debug, Serialize)] +#[derive(Clone, Debug, Serialize, PartialEq)] pub struct Command { pub command: String, pub(crate) args: Value, @@ -237,19 +241,25 @@ impl Command { impl Command { pub fn new(input: CommandInput, scope: &mut Scope) -> ResultVec { if let Some(_) = input.id { - return Err(err("`id` fields is reserved"))?; + return Err(err("`id` field is reserved"))?; } return Ok(Command { command: resolve!(input, command, scope)?, args: match input.args { Some(x) => x.into_inner(), - None => Value::Table(HashMap::new()), + Option::None => Value::Table(HashMap::new()), }, skipWhen: resolve!(input, skipWhen, scope)?, }); } } +impl Resolving for CommandInput { + fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { + return Ok(Command::new(self, scope)?); + } +} + #[cfg(test)] mod tests { use crate::bind::command::regularize_commands; diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 12ce7681..c04e7e97 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -247,6 +247,7 @@ lazy_static! { // static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); } +#[allow(non_snake_case)] pub fn expression_fn__keys( val: ImmutableString, ) -> std::result::Result> { diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 1a559cfd..7170e9e7 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -5,7 +5,7 @@ pub mod value; #[allow(unused_imports)] use log::info; -use std::collections::{HashMap, VecDeque}; +use std::collections::{HashMap, HashSet, VecDeque}; use rhai::Dynamic; use serde::Serialize; @@ -81,7 +81,7 @@ use crate::{ /// the current set of keybindigs /// - `all_modes()`: returns an array of strings all keybinding modes defined by the current /// keybinding set -/// - `all_modes_but([exclusions])`: given an array of strings of excluded modes, returns +/// - `not_modes([exclusions])`: given an array of strings of excluded modes, returns /// all keybinding modes defined by the current keybinding set that are not among these /// exclusions. /// @@ -115,7 +115,9 @@ use crate::{ #[wasm_bindgen] pub struct Scope { pub(crate) asts: HashMap, - engine: rhai::Engine, + pub(crate) engine: rhai::Engine, + pub(crate) modes: HashSet, + pub(crate) default_mode: String, pub(crate) state: rhai::Scope<'static>, pub(crate) queues: HashMap>, } @@ -180,6 +182,8 @@ impl Scope { asts: HashMap::new(), engine: engine, state: rhai::Scope::new(), + default_mode: "default".to_string(), + modes: HashSet::from(["default".to_string()]), queues: HashMap::new(), }; } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index fbccbf68..4f2983ba 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -15,7 +15,7 @@ use toml::Spanned; use crate::bind::UNKNOWN_RANGE; use crate::err; -use crate::error::{Error, ErrorContext, ErrorSet, RawError, Result, ResultVec, flatten_errors}; +use crate::error::{Error, ErrorContext, ErrorSet, Result, ResultVec, err, flatten_errors}; use crate::expression::Scope; use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; @@ -274,7 +274,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match let mut error = None; if content.contains("{{") { error = Some(Error { - error: RawError::Static("unexpected `{{`"), + error: err("unexpected `{{`"), contexts: smallvec![crate::error::Context::Range(exp_span.clone())], }); } @@ -289,7 +289,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match let mut error = None; if content.contains("{{") { error = Some(Error { - error: RawError::Static("unexpected `{{`"), + error: err("unexpected `{{`"), contexts: smallvec![], }); } @@ -304,7 +304,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match fn check_unmatched_braces(x: String, span: Option>) -> Value { if x.contains("{{") { - let mut error: Error = RawError::Static("unexpected `{{`").into(); + let mut error: Error = err("unexpected `{{`").into(); if let Some(r) = span.clone() { error.contexts.push(crate::error::Context::Range(r)); }; @@ -315,7 +315,7 @@ fn check_unmatched_braces(x: String, span: Option>) -> Value { scope: SmallVec::new(), }); } else if x.contains("}}") { - let mut error: Error = RawError::Static("unexpected `}}`").into(); + let mut error: Error = err("unexpected `}}`").into(); if let Some(r) = span.clone() { error.contexts.push(crate::error::Context::Range(r.clone())); }; @@ -396,9 +396,7 @@ impl TryFrom for BareValue { if i32::try_from(x).is_ok() { x as i32 } else { - Err(RawError::Static( - "i64 value was too large (must fit in i32)", - ))?; + Err(err("i64 value was too large (must fit in i32)"))?; 0 } }), diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 811e1513..5e36244e 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -85,10 +85,11 @@ #[allow(unused_imports)] use log::info; -use crate::bind::{Binding, BindingInput}; +use crate::bind::{Binding, BindingInput, UNKNOWN_RANGE}; use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; use crate::expression::Scope; +use crate::mode::{ModeInput, Modes}; use serde::{Deserialize, Serialize}; use toml::Spanned; @@ -98,6 +99,7 @@ use wasm_bindgen::prelude::*; #[derive(Deserialize, Clone, Debug)] struct KeyFileInput { define: Option, + mode: Option>>, bind: Option>>, } @@ -105,15 +107,19 @@ struct KeyFileInput { #[wasm_bindgen] pub struct KeyFile { define: Define, + modes: Modes, bind: Vec, } // TODO: implement methods to access/store bindings impl KeyFile { + // TODO: refactor to have each section's processing in corresponding module + // for that section fn new(input: KeyFileInput, mut scope: &mut Scope) -> ResultVec { - // [[define]] let mut errors = Vec::new(); + + // [[define]] let define_input = input.define.unwrap_or_default(); let mut define = match Define::new(define_input, &mut scope) { Err(mut es) => { @@ -123,6 +129,18 @@ impl KeyFile { Ok(x) => x, }; + // [[mode]] + let mode_input = input + .mode + .unwrap_or_else(|| vec![Spanned::new(UNKNOWN_RANGE, ModeInput::default())]); + let modes = match Modes::new(mode_input, &mut scope) { + Err(mut es) => { + errors.append(&mut es.errors); + Modes::default() + } + Ok(x) => x, + }; + // [[bind]] let input_iter = input .bind @@ -178,7 +196,11 @@ impl KeyFile { .collect(); if errors.len() == 0 { - return Ok(KeyFile { define, bind }); + return Ok(KeyFile { + define, + bind, + modes, + }); } else { return Err(errors.into()); } @@ -228,6 +250,10 @@ mod tests { [[define.val]] foo = "bar" + [[mode]] + name = "normal" + default = true + [[bind]] key = "l" mode = "normal" @@ -420,6 +446,170 @@ mod tests { assert_eq!(result.bind[0].commands[0].command, "bar"); } + #[test] + fn just_one_default_mode() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "b" + default = true + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("default mode already set")); + assert_eq!(report[0].range.start.line, 5) + } + + #[test] + fn includes_default_mode() { + let data = r#" + [[mode]] + name = "a" + + [[mode]] + name = "b" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!( + report[0] + .message + .contains("exactly one mode must be the default") + ); + assert_eq!(report[0].range.start.line, 0) + } + + #[test] + fn unique_mode_name() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "a" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("mode name is not unique")); + assert_eq!(report[0].range.start.line, 5) + } + + #[test] + fn parse_use_mode() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "b" + whenNoBinding.useMode = "a" + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert_eq!( + result.modes.get("b").unwrap().whenNoBinding, + crate::mode::WhenNoBinding::UseMode("a".to_string()) + ) + } + + #[test] + fn validate_use_mode() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "b" + whenNoBinding.useMode = "c" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("mode `c` is not defined")); + assert_eq!(report[0].range.start.line, 7) + } + + #[test] + fn eval_mode_expressions() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "b" + + [[mode]] + name = "c" + + [[bind]] + key = "a" + command = "foo" + mode = '{{all_modes()}}' + + [[bind]] + key = "b" + command = "bar" + mode = '{{not_modes(["c"])}}' + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert!(result.bind[0].mode.iter().any(|x| x == "a")); + assert!(result.bind[0].mode.iter().any(|x| x == "b")); + assert!(result.bind[0].mode.iter().any(|x| x == "c")); + assert!(result.bind[1].mode.iter().any(|x| x == "a")); + assert!(result.bind[1].mode.iter().any(|x| x == "b")); + assert!(!result.bind[1].mode.iter().any(|x| x == "c")); + } + + #[test] + fn validate_mode_expressions() { + let data = r#" + [[mode]] + name = "a" + default = true + + [[mode]] + name = "b" + + [[mode]] + name = "c" + + [[bind]] + key = "b" + command = "bar" + mode = '{{not_modes(["d"])}}' + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("mode `d`")); + assert_eq!(report[0].range.start.line, 14) + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index e6750018..3048299d 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -6,6 +6,7 @@ mod util; // define file sections mod bind; mod define; +mod mode; // top level parsing pub mod file; diff --git a/src/rust/parsing/src/mode.rs b/src/rust/parsing/src/mode.rs new file mode 100644 index 00000000..7b743233 --- /dev/null +++ b/src/rust/parsing/src/mode.rs @@ -0,0 +1,312 @@ +#[allow(unused_imports)] +use log::info; + +use rhai::{EvalAltResult, ImmutableString}; +use serde::{Deserialize, Serialize}; +use std::collections::{HashMap, HashSet}; +use toml::Spanned; +use wasm_bindgen::prelude::*; + +use crate::bind::UNKNOWN_RANGE; +use crate::bind::command::{Command, CommandInput}; +use crate::err; +use crate::error::{ErrorContext, ResultVec, err}; +use crate::expression::Scope; +use crate::resolve; +use crate::util::{LeafValue, Plural, Resolving}; + +/// @bindingField mode +/// @description array describing behavior of keybinding modes +/// +/// The `mode` element defines a distinct keybinding mode. Like vim modes, they affect which +/// keybindings are currently active. +/// +/// **Example** +/// +/// ```toml +/// [[mode]] +/// name = "normal" +/// default = true +/// cursorShape = "Block" +/// highlight = "Highlight" +/// +/// [[mode]] +/// name = "insert" +/// cursorShape = "Line" +/// highlight = "NoHighlight" +/// whenNoBinding = "insert" +/// ``` +/// +/// If no keybinding modes are defined, an implicit mode is defined as follows: +/// +/// ```toml +/// [[mode]] +/// name = "default" +/// default = true +/// cursorShape = "Line" +/// highlight = "NoHighlight" +/// whenNoBinding = "insert" +/// ``` +/// +/// ## Fields +/// +/// The only required field for a mode is its name (marked with "*") but there are a number +/// of optional fields that impact the behavior of the mode. + +#[allow(non_snake_case)] +#[derive(Deserialize, Clone, Debug)] +pub struct ModeInput { + /// @forBindingField mode + /// + /// - `name`*: The name of the mode; displayed in the bottom left corner of VSCode + name: String, + + /// @forBindingField mode + /// + /// - `default`: whether this mode is the default when the editor is opened. There + /// should be exactly one default mode. All keybindings without an explicit + /// mode are defined to use this mode. + default: Option, + /// @forBindingField mode + /// + /// - `highlight`: Whether and how to highlight the name of this mode in the bottom left + /// corner of VSCode. Possible values are: + /// - `NoHighlight` does not add coloring + /// - `Highlight` adds warning related colors (usually orange) + /// - `Alert` adds error related colors (usually red) + highlight: Option, + /// @forBindingField mode + /// + /// - `cursorShape`: The shape of the cursor when in this mode. One of the following: + /// - `Line` + /// - `Block` + /// - `Underline` + /// - `LineThin` + /// - `BlockOutline` + /// - `UnderlineThin` + cursorShape: Option, + /// @forBindingField mode + /// + /// - `whenNoBinding`: How to respond to keys when there is no key binding in this mode. + /// The options are + /// - `"ignore"`: Prevent the key from doing anything. This is the default when you + /// explicitly define a mode + /// - `"insert"`: The keys should insert text. This is true for the implicitly defined + /// "default" mode. + /// - `"useMode": "[mode]"`: fallback to the keybindings defined for another mode + /// - `"run": | []`: set `key.capture` to a string representing + /// the key pressed and run the given command or commands, as per the fields allowed + /// when [running multiple commands](#running-multiple-commands) in `[[bind]]`. + #[serde(default)] + whenNoBinding: Option>, +} + +impl Default for ModeInput { + fn default() -> Self { + return ModeInput { + name: "default".to_string(), + default: Some(true), + highlight: None, + cursorShape: None, + whenNoBinding: Some(Spanned::new(UNKNOWN_RANGE, WhenNoBindingInput::Insert)), + }; + } +} + +#[derive(Clone, Debug, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub enum WhenNoBindingInput { + #[default] + Ignore, + Insert, + UseMode(String), + Run(Plural), +} + +impl LeafValue for WhenNoBindingInput {} + +#[derive(Deserialize, Serialize, Clone, Debug, Default)] +pub enum ModeHighlight { + #[default] + NoHighlight, + Highlight, + Alert, +} +impl LeafValue for ModeHighlight {} + +#[derive(Deserialize, Serialize, Clone, Debug, Default)] +pub enum CursorShape { + #[default] + Line, + Block, + Underline, + LineThin, + BlockOutline, + UnderlineThin, +} +impl LeafValue for CursorShape {} + +// TODO: get wasm interface worked out +#[derive(Clone, Debug, Serialize)] +#[allow(non_snake_case)] +pub struct Mode { + pub name: String, + pub default: bool, + pub highlight: ModeHighlight, + pub cursorShape: CursorShape, + pub whenNoBinding: WhenNoBinding, +} + +#[derive(Clone, Debug, Serialize, Default, PartialEq)] +pub enum WhenNoBinding { + #[default] + Ignore, + Insert, + UseMode(String), + Run(Vec), +} + +impl LeafValue for WhenNoBinding {} + +impl Resolving for WhenNoBindingInput { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec { + return Ok(match self { + WhenNoBindingInput::Ignore => WhenNoBinding::Ignore, + WhenNoBindingInput::Insert => WhenNoBinding::Insert, + WhenNoBindingInput::UseMode(mode) => WhenNoBinding::UseMode(mode.resolve(name, scope)?), + WhenNoBindingInput::Run(commands) => WhenNoBinding::Run(commands.resolve(name, scope)?), + }); + } +} + +#[wasm_bindgen] +impl Mode { + pub(crate) fn new(input: ModeInput, scope: &mut Scope) -> ResultVec { + if let Some(ref x) = input.whenNoBinding { + let span = x.span().clone(); + if let WhenNoBindingInput::UseMode(mode) = x.as_ref() { + if !scope.modes.contains(mode) { + Err(err!("mode `{mode}` is not defined")).with_range(&span)?; + } + } + } + return Ok(Mode { + name: resolve!(input, name, scope)?, + default: resolve!(input, default, scope)?, + highlight: resolve!(input, highlight, scope)?, + cursorShape: resolve!(input, cursorShape, scope)?, + whenNoBinding: resolve!(input, whenNoBinding, scope)?, + }); + } +} + +#[derive(Serialize, Clone, Debug)] +#[wasm_bindgen(getter_with_clone)] +pub struct Modes { + map: HashMap, + pub default: String, +} + +impl Modes { + pub(crate) fn new(input: Vec>, scope: &mut Scope) -> ResultVec { + // define the set of available modes + let mut all_mode_names = HashSet::new(); + let mut default_mode = None; + let mut first_mode_span = UNKNOWN_RANGE; + for mode in &input { + if first_mode_span != UNKNOWN_RANGE { + first_mode_span = mode.span().clone(); + } + let mode_name = mode.as_ref().name.clone(); + if all_mode_names.contains(&mode_name) { + Err(err("mode name is not unique")).with_range(&mode.span())?; + } + if mode.as_ref().default.unwrap_or_default() { + if let Some(old_default) = default_mode { + return Err(err!("default mode already set to `{old_default}")) + .with_range(&mode.span())?; + } + default_mode = Some(mode_name.clone()); + } + all_mode_names.insert(mode_name); + } + if let Option::None = default_mode { + // we `unwrap` here because we do not expect vec to ever get an + // empty vector (the default contains a single mode) + Err(err("exactly one mode must be the default")).with_range(&first_mode_span)? + } + + // make the set of available modes accessible to expressions + scope.modes = all_mode_names; + scope.default_mode = default_mode.clone().unwrap(); + + let all_modes_fn_data = scope.modes.clone(); + scope.engine.register_fn("all_modes", move || { + all_modes_fn_data + .iter() + .map(|x| rhai::Dynamic::from(ImmutableString::from(x))) + .collect::() + }); + let not_modes_fn_data = scope.modes.clone(); + scope.engine.register_fn( + "not_modes", + move |x: rhai::Array| -> std::result::Result> { + let not_modes = x + .into_iter() + .map(|xi| xi.into_immutable_string()) + .collect::, _>>()?; + let mut result = rhai::Array::new(); + for mode in ¬_modes_fn_data { + if not_modes.iter().all(|x| x != mode) { + result.push(rhai::Dynamic::from(ImmutableString::from(mode))); + } + } + if result.len() == (¬_modes_fn_data).len() { + let mut bad_mode = None; + for mode in not_modes { + if (¬_modes_fn_data).iter().all(|x| x != mode) { + bad_mode = Some(mode); + break; + } + } + return Err(format!("mode `{}` does not exist", bad_mode.unwrap()).into()); + } + return Ok(result); + }, + ); + + // create `Mode` objects + let mut modes = HashMap::new(); + for mode in input { + let span = mode.span().clone(); + modes.insert( + mode.as_ref().name.clone(), + Mode::new(mode.into_inner(), scope).with_range(&span)?, + ); + } + + return Ok(Modes { + map: modes, + default: default_mode.unwrap(), + }); + } + + pub fn get(&self, x: &str) -> Option<&Mode> { + return self.map.get(x); + } +} + +impl Default for Modes { + fn default() -> Self { + return Modes { + map: HashMap::new(), + default: "default".to_string(), + }; + } +} + +impl Resolving for ModeInput { + fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { + return Ok(Mode::new(self, scope)?); + } +} diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 273975dd..c5454b7b 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -203,6 +203,22 @@ impl Merging for toml::Value { } } +// +// ---------------- ClosedSet ---------------- +// + +pub enum Subset { + Some(Vec), + AllBut(Vec), + All, +} + +impl From> for Subset { + fn from(value: Vec) -> Subset { + return Subset::Some(value); + } +} + // // ---------------- Resolving ---------------- // From 9e4db64d7972a4eafbf4e407abf00d1681f5d0ca Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 30 Sep 2025 12:31:04 -0400 Subject: [PATCH 58/79] `combined` doc fields moved Created using spr 1.3.6-beta.1 --- notes.md | 2 +- src/presets/larkin.toml | 590 +++++++++++++++++------------------ src/rust/parsing/src/bind.rs | 179 +++++++---- 3 files changed, 413 insertions(+), 358 deletions(-) diff --git a/notes.md b/notes.md index 8c62b286..7cf4a380 100644 --- a/notes.md +++ b/notes.md @@ -201,7 +201,7 @@ Integration test debugging: - [X] get existing unit tests working - [X] write test cases for error paths - [X] write tests for expressions to specify modes - - [ ] move `combinedName` and friends to `combined.name` and friends + - [X] move `combinedName` and friends to `combined.name` and friends - [~] command normalization - [X] always `runCommand` with an array of objects with `command` field - [ ] flatten all nested `runCommands` calls diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 22b0fab3..43d5361a 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -157,9 +157,9 @@ default = "{{bind.modes}}" doc.name = "normal" doc.description = "Enter normal mode" foreach.key = ["escape", "ctrl+["] -doc.combinedKey = "escape/ctrl+[" -doc.combinedName = "normal" -doc.combinedDescription = "Enter normal mode" +doc.combined.key = "escape/ctrl+[" +doc.combined.name = "normal" +doc.combined.description = "Enter normal mode" key = "{{key}}" mode = "{{all_modes()}}" doc.hideInPalette = true @@ -230,9 +230,9 @@ args.select = "{{editorHasSelection || val.select}}" default = "{{bind.edit_motion_prim}}" key = "h" doc.name = "←" -doc.combinedName = "←/→" -doc.combinedKey = "h/l" -doc.combinedDescription = "move left/right" +doc.combined.name = "←/→" +doc.combined.key = "h/l" +doc.combined.description = "move left/right" doc.description = "move left" args.to = "left" mode = "normal" @@ -240,7 +240,7 @@ mode = "normal" [[bind]] default = "{{bind.edit_motion_prim}}" key = "l" -doc.combinedName = "←/→" +doc.combined.name = "←/→" doc.name = "→" doc.description = "move right" args.to = "right" @@ -249,9 +249,9 @@ args.to = "right" default = "{{bind.edit_motion_prim}}" key = "j" doc.name = "↓" -doc.combinedName = "↓/↑" -doc.combinedKey = "j/k" -doc.combinedDescription = "move down/up" +doc.combined.name = "↓/↑" +doc.combined.key = "j/k" +doc.combined.description = "move down/up" doc.description = "move down" args.to = "down" args.by = "wrappedLine" @@ -261,7 +261,7 @@ default = "{{bind.edit_motion_prim}}" key = "k" doc.name = "↑" doc.description = "move up" -doc.combinedName = "↓/↑" +doc.combined.name = "↓/↑" args.to = "up" args.by = "wrappedLine" @@ -270,16 +270,16 @@ default = "{{bind.edit_motion_prim}}" key = "shift+h" doc.name = "start" doc.description = "start of line (alternates between first non-white and first)" -doc.combinedName = "start/end" -doc.combinedKey = "shift+h/shift+l" -doc.combinedDescription = "move to start/end of line" +doc.combined.name = "start/end" +doc.combined.key = "shift+h/shift+l" +doc.combined.description = "move to start/end of line" command = "cursorHomeSelect" [[bind]] # we don't use prim because we don't want the defaults default = "{{bind.edit_motion}}" key = "shift+l" doc.name = "end" -doc.combinedName = "start/end" +doc.combined.name = "start/end" doc.description = "end of line" command = "cursorMove" args.to = "wrappedLineEnd" @@ -289,9 +289,9 @@ args.select = true default = "{{bind.edit_motion_prim}}" key = "shift+k" doc.name = "sel ↑" -doc.combinedName = "sel ↑/↓" -doc.combinedDescription = "select lines up/down" -doc.combinedKey = "shift+k/shift+j" +doc.combined.name = "sel ↑/↓" +doc.combined.description = "select lines up/down" +doc.combined.key = "shift+k/shift+j" doc.description = "select lines upwards" command = "runCommands" @@ -312,7 +312,7 @@ command = "selection-utilities.exchangeAnchorActive" default = "{{bind.edit_motion_prim}}" key = "shift+j" doc.name = "sel ↓" -doc.combinedName = "sel ↑/↓" +doc.combined.name = "sel ↑/↓" doc.description = "select lines downwards" command = "runCommands" @@ -331,9 +331,9 @@ default = "{{bind.edit_motion_prim}}" key = "ctrl+d" mode = '{{not_modes(["normal", "insert"]}}' doc.name = "pg ↓" -doc.combinedName = "pg ↓/↑" -doc.combinedKey = "ctrl+d/ctrl+u" -doc.combinedDescription = "move down/up, relative to page size" +doc.combined.name = "pg ↓/↑" +doc.combined.key = "ctrl+d/ctrl+u" +doc.combined.description = "move down/up, relative to page size" doc.description = "move down, relative to page size" command = "selection-utilities.activePageMove" args.dir = "down" @@ -345,7 +345,7 @@ default = "{{bind.edit_motion_prim}}" key = "ctrl+u" mode = '{{not_modes(["normal", "insert"]}}' doc.name = "pg ↑" -doc.combinedName = "pg ↓/↑" +doc.combined.name = "pg ↓/↑" doc.description = "move up, relative to page size" command = "selection-utilities.activePageMove" args.dir = "up" @@ -371,9 +371,9 @@ default = "{{bind.edit_motion_obj}}" key = "w" doc.name = "subwrd →" doc.description = "next subword (camel/snake case)" -doc.combinedName = "subwrd ←/→" -doc.combinedDescription = "next/prev subword (camel/snake case)" -doc.combinedKey = "w/b" +doc.combined.name = "subwrd ←/→" +doc.combined.description = "next/prev subword (camel/snake case)" +doc.combined.key = "w/b" args.unit = "subword" args.value = "{{count || 1}}" @@ -382,7 +382,7 @@ default = "{{bind.edit_motion_obj}}" key = "b" doc.name = "subwrd ←" doc.description = "previous subword (camel/snake case)" -doc.combinedName = "subwrd ←/→" +doc.combined.name = "subwrd ←/→" args.unit = "subword" args.value = "{{-count || -1}}" @@ -391,9 +391,9 @@ default = "{{bind.edit_motion_obj}}" key = "shift+w" doc.name = "word →" doc.description = "next word" -doc.combinedName = "word ←/→" -doc.combinedDescription = "next/prev word" -doc.combinedKey = "shift+w/b" +doc.combined.name = "word ←/→" +doc.combined.description = "next/prev word" +doc.combined.key = "shift+w/b" args.unit = "word" args.value = "{{count || 1}}" @@ -401,7 +401,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_obj}}" key = "shift+b" doc.name = "word ←" -doc.combinedName = "word ←/→" +doc.combined.name = "word ←/→" doc.description = "previous word" args.unit = "word" args.value = "{{-count || -1}}" @@ -429,9 +429,9 @@ default = "{{bind.edit_motion_obj}}" key = "shift+]" doc.name = "parag. →" doc.description = "next paragraph" -doc.combinedName = "paragraph →/←" -doc.combinedDescription = "next/previous paragraph" -doc.combinedKey = "shift+]/[" +doc.combined.name = "paragraph →/←" +doc.combined.description = "next/previous paragraph" +doc.combined.key = "shift+]/[" args.unit = "paragraph" args.value = "{{count || 1}}" @@ -439,7 +439,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_obj}}" key = "shift+[" doc.name = "parag. ←" -doc.combinedName = "paragraph →/←" +doc.combined.name = "paragraph →/←" doc.description = "previous paragraph" args.unit = "paragraph" args.value = "{{-(count || 1)}}" @@ -449,9 +449,9 @@ default = "{{bind.edit_motion_obj}}" key = "shift+0" doc.name = "subsec →" doc.description = "next subsection" -doc.combinedName = "subsec →/←" -doc.combinedDescription = "next/previous subsection" -doc.combinedKey = "shift+0/9" +doc.combined.name = "subsec →/←" +doc.combined.description = "next/previous subsection" +doc.combined.key = "shift+0/9" args.unit = "subsection" args.value = "{{count || 1}}" @@ -460,7 +460,7 @@ default = "{{bind.edit_motion_obj}}" key = "shift+9" doc.name = "subsec ←" doc.description = "previous subsection" -doc.combinedName = "subsec →/←" +doc.combined.name = "subsec →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" @@ -468,8 +468,8 @@ args.value = "{{-(count || 1)}}" default = "{{bind.edit_motion_prim}}" key = "v" doc.name = "shrink selection" -doc.combinedName = "shrink/hold selection" -doc.combinedDescription = """ +doc.combined.name = "shrink/hold selection" +doc.combined.description = """ reduce selections to zero length / make all commands extend the selection """ doc.description = """ @@ -485,7 +485,7 @@ args.commands = [ default = "{{bind.edit_motion}}" key = "shift+v" doc.name = "hold selection" -doc.combinedName = "shrink/hold selection" +doc.combined.name = "shrink/hold selection" doc.description = """ all motions extend the selection """ @@ -498,9 +498,9 @@ default = "{{bind.edit_action}}" doc.name = "open, act →" doc.description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" key = "o" -doc.combinedName = "open below/above, act →/←" -doc.combinedKey = "o/shift+o" -doc.combinedDescription = """ +doc.combined.name = "open below/above, act →/←" +doc.combined.key = "o/shift+o" +doc.combined.description = """ without selection: open a line below/above current line and enter insert, with selection: move cursor to end/start of selection """ @@ -511,14 +511,14 @@ args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] [[bind]] default = "{{bind.edit_action}}" key = "o" -doc.combinedName = "open below/above, act →/←" +doc.combined.name = "open below/above, act →/←" when = "editorHasSelection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_action}}" doc.name = "open blw, act ←" -doc.combinedName = "open below/above, act →/←" +doc.combined.name = "open below/above, act →/←" doc.description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" key = "shift+o" when = "!editorHasSelection" @@ -528,7 +528,7 @@ args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] default = "{{bind.edit_action}}" doc.name = "open blw, act ←" -doc.combinedName = "open below/above, act →/←" +doc.combined.name = "open below/above, act →/←" doc.description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" key = "shift+o" when = "editorHasSelection" @@ -545,10 +545,10 @@ command = "editor.action.jumpToBracket" default = "{{bind.edit_motion_prim}}" key = '\' doc.name = "→ sel" -doc.combinedName = "→/← sel" +doc.combined.name = "→/← sel" doc.description = "select *just* the character to the right" -doc.combinedDescription = "select *just* the character to the right" -doc.combinedKey = 'shift+\/\' +doc.combined.description = "select *just* the character to the right" +doc.combined.key = 'shift+\/\' mode = '{{not_modes(["normal", "selectedit"]}}' command = "runCommands" @@ -563,7 +563,7 @@ args = { to = "right", select = true, value = "{{count}}" } default = "{{bind.edit_motion_prim}}" key = 'shift+\' doc.name = "← sel" -doc.combinedName = "→/← sel" +doc.combined.name = "→/← sel" doc.description = "select *just* the character to the left" mode = '{{not_modes(["normal", "selectedit"]}}' command = "runCommands" @@ -594,9 +594,9 @@ default = "{{bind.edit_motion_obj}}" doc.name = "→ num." doc.description = "Move to next number" key = "shift+3" -doc.combinedName = "→/← num." -doc.combinedDescription = "Move to next/prev number" -doc.combinedKey = "shift+3/2" +doc.combined.name = "→/← num." +doc.combined.description = "Move to next/prev number" +doc.combined.key = "shift+3/2" args.unit = "number" args.selectWhole = true args.boundary = "both" @@ -607,7 +607,7 @@ default = "{{bind.edit_motion_obj}}" doc.name = "← num." doc.description = "Move to next number" key = "shift+2" -doc.combinedName = "→/← num." +doc.combined.name = "→/← num." args.unit = "number" args.selectWhole = true args.boundary = "both" @@ -634,9 +634,9 @@ doc.name = "count {{num}}" key = "{{num}}" command = "master-key.updateCount" doc.description = "Add digit {{num}} to the count argument of a command" -doc.combinedKey = "0-9" -doc.combinedName = "count 0-9" -doc.combinedDescription = "Add digit 1-9 to count argument of a command" +doc.combined.key = "0-9" +doc.combined.name = "count 0-9" +doc.combined.description = "Add digit 1-9 to count argument of a command" args.value = "{{num}}" finalKey = false mode = '{{not_modes(["insert", "capture"])}}' @@ -680,14 +680,14 @@ commandHistory[index+1].tags.contains("history")) default = "{{bind.edit_motion}}" doc.name = "cursor undo" key = "-" -doc.combinedName = "cursor undo/redo" -doc.combinedKey = "-/shift+-" +doc.combined.name = "cursor undo/redo" +doc.combined.key = "-/shift+-" command = "cursorUndo" [[bind]] default = "{{bind.edit_motion}}" doc.name = "cursor redo" -doc.combinedName = "cursor undo/redo" +doc.combined.name = "cursor undo/redo" key = "shift+-" command = "cursorRedo" @@ -695,16 +695,16 @@ command = "cursorRedo" default = "{{bind.edit_motion}}" doc.name = "nav ←" doc.description = "Go back in navigation history (e.g. goto definition)" -doc.combinedName = "nav ←/→" -doc.combinedKey = "n/shift+n" -doc.combinedDescription = "Go back/forward in navigation history" +doc.combined.name = "nav ←/→" +doc.combined.key = "n/shift+n" +doc.combined.description = "Go back/forward in navigation history" key = "g n" command = "workbench.action.navigateBackInNavigationLocations" [[bind]] default = "{{bind.edit_motion}}" doc.name = "nav →" -doc.combinedName = "nav ←/→" +doc.combined.name = "nav ←/→" doc.description = "Go forward in navigation history (e.g. goto definition)" key = "g shift+n" command = "workbench.action.navigateForwardInNavigationLocations" @@ -714,9 +714,9 @@ default = "{{bind.edit_motion}}" doc.name = "edit hist ←" doc.description = "Go back in edit history" key = "g -" -doc.combinedName = "edit ←/→" -doc.combinedKey = "-/shift+-" -doc.combinedDescription = "Go back/forward in edit history" +doc.combined.name = "edit ←/→" +doc.combined.key = "-/shift+-" +doc.combined.description = "Go back/forward in edit history" command = "workbench.action.navigateBackInEditLocations" [[bind]] @@ -724,7 +724,7 @@ default = "{{bind.edit_motion}}" doc.name = "edit hist →" doc.description = "Go forward in edit history)" key = "g shift+-" -doc.combinedName = "edit ←/→" +doc.combined.name = "edit ←/→" command = "workbench.action.navigateForwardInEditLocations" # ## Search Motions @@ -747,9 +747,9 @@ default = "{{bind.edit_motion_search}}" key = "/" doc.name = "search →" doc.description = "search forwards" -doc.combinedName = "search → (←)" -doc.combinedDescription = "search forwards (backwards)" -doc.combinedKey = "/ (shift+/)" +doc.combined.name = "search → (←)" +doc.combined.description = "search forwards (backwards)" +doc.combined.key = "/ (shift+/)" args.offset = "start" args.register = "search" @@ -758,7 +758,7 @@ default = "{{bind.edit_motion_search}}" key = "shift+/" doc.name = "search ←" doc.description = "search backwards" -doc.combinedName = "search → (←)" +doc.combined.name = "search → (←)" args.offset = "start" args.register = "search" args.backwards = true @@ -786,9 +786,9 @@ default = "{{bind.edit_motion_search}}" key = "shift+8" doc.name = "match →" doc.description = "Next match to object under cursor" -doc.combinedName = "match →/←" -doc.combinedDescription = "Next/previous match to object under cursor" -doc.combinedKey = "shift+8/7" +doc.combined.name = "match →/←" +doc.combined.description = "Next/previous match to object under cursor" +doc.combined.key = "shift+8/7" args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" @@ -798,7 +798,7 @@ default = "{{bind.edit_motion_search}}" key = "shift+7" doc.name = "match ←" doc.description = "Previous match to object under cursor" -doc.combinedName = "match →/←" +doc.combined.name = "match →/←" args.text = "{{firstSelectionOrWord}}" args.offset = "start" args.register = "search" @@ -809,9 +809,9 @@ default = "{{bind.edit_motion_search}}" key = "f" doc.name = "find char" doc.description = "Find the next char (include char in selection)" -doc.combinedName = "find char (back)" -doc.combinedDescription = "Find the next (previous) char (include char in selection)" -doc.combinedKey = "f (shift+f)" +doc.combined.name = "find char (back)" +doc.combined.description = "Find the next (previous) char (include char in selection)" +doc.combined.key = "f (shift+f)" args.acceptAfter = 1 args.skip = "{{count-1}}" args.offset = "inclusive" @@ -821,7 +821,7 @@ default = "{{bind.edit_motion_search}}" key = "shift+f" doc.name = "find char back" doc.description = "Find the previous char (include char in selection)" -doc.combinedName = "find char (back)" +doc.combined.name = "find char (back)" args.acceptAfter = 1 args.offset = "inclusive" args.backwards = true @@ -832,9 +832,9 @@ default = "{{bind.edit_motion_search}}" key = "t" doc.name = "to char" doc.description = "Find the next char (exclude char in selection)" -doc.combinedName = "to char (back)" -doc.combinedKey = "t (shift+t)" -doc.combinedDescription = "Find the next/previous char (exclude char in selection)" +doc.combined.name = "to char (back)" +doc.combined.key = "t (shift+t)" +doc.combined.description = "Find the next/previous char (exclude char in selection)" args.acceptAfter = 1 args.offset = "start" args.skip = "{{count-1}}" @@ -844,7 +844,7 @@ default = "{{bind.edit_motion_search}}" key = "shift+t" doc.name = "to char back" doc.description = "Find the previous char (exclude char in selection)" -doc.combinedName = "to char (back)" +doc.combined.name = "to char (back)" args.acceptAfter = 1 args.offset = "end" args.backwards = true @@ -855,9 +855,9 @@ default = "{{bind.edit_motion_search}}" key = "s" doc.name = "find char pair" doc.description = "To next character pair" -doc.combinedName = "char pair →/←" -doc.combinedDescription = "To next character pair" -doc.combinedKey = "s/shift+s" +doc.combined.name = "char pair →/←" +doc.combined.description = "To next character pair" +doc.combined.key = "s/shift+s" args.acceptAfter = 2 args.offset = "start" args.skip = "{{count-1}}" @@ -868,7 +868,7 @@ default = "{{bind.edit_motion_search}}" key = "shift+s" doc.name = "char pair back" doc.description = "To previous character pair" -doc.combinedName = "char pair →/←" +doc.combined.name = "char pair →/←" args.acceptAfter = 2 args.offset = "start" args.skip = "{{count-1}}" @@ -895,9 +895,9 @@ default = "{{bind.edit_motion_prim}}" key = "g j" priority = 1 doc.name = "unwrp ↓" -doc.combinedName = "unwrap ↓/↑" -doc.combinedKey = "j/k" -doc.combinedDescription = """ +doc.combined.name = "unwrap ↓/↑" +doc.combined.key = "j/k" +doc.combined.description = """ move cursor up/down unwrapped text line; if a single line is wrapped into multiple lines by the editor, this command skips all such wrapped lines """ @@ -913,7 +913,7 @@ default = "{{bind.edit_motion_prim}}" key = "g k" priority = 1 doc.name = "unwrp ↑" -doc.combinedName = "unwrap ↓/↑" +doc.combined.name = "unwrap ↓/↑" doc.description = "up unwrapped line" args.to = "up" args.by = "line" @@ -922,9 +922,9 @@ args.by = "line" default = "{{bind.edit_motion_prim}}" key = "g shift+k" priority = 1 -doc.combinedName = "unwrp sel ↑/↓" -doc.combinedDescription = "select unwrapped lines up/down" -doc.combinedKey = "shift+k/j" +doc.combined.name = "unwrp sel ↑/↓" +doc.combined.description = "select unwrapped lines up/down" +doc.combined.key = "shift+k/j" doc.name = "unwrp sel ↑" doc.description = "select unwrapped lines upwards" command = "runCommands" @@ -945,7 +945,7 @@ default = "{{bind.edit_motion_prim}}" key = "g shift+j" priority = 1 doc.name = "sel ↓" -doc.combinedName = "unwrp sel ↑/↓" +doc.combined.name = "unwrp sel ↑/↓" doc.description = "select unwrapped lines downwards" command = "runCommands" @@ -966,9 +966,9 @@ key = "shift+g" priority = 1 doc.name = "doc end" doc.description = "select to end of document" -doc.combinedName = "doc top/bottom" -doc.combinedDescription = "select to top/bottom of document" -doc.combinedKey = ",/." +doc.combined.name = "doc top/bottom" +doc.combined.description = "select to top/bottom of document" +doc.combined.key = ",/." command = "cursorBottomSelect" [[bind]] @@ -1008,11 +1008,11 @@ default = "{{bind.edit_motion_obj}}" key = "g w" priority = 1 doc.name = "WORD →" -doc.combinedName = "WORD →/←" -doc.combinedDescription = """ +doc.combined.name = "WORD →/←" +doc.combined.description = """ next/prev WORD; e.g. contiguous non-whitespace region """ -doc.combinedKey = "w/b" +doc.combined.key = "w/b" doc.description = "next WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" args.value = "{{count || 1}}" @@ -1022,7 +1022,7 @@ default = "{{bind.edit_motion_obj}}" key = "g b" priority = 1 doc.name = "WORD ←" -doc.combinedName = "WORD →/←" +doc.combined.name = "WORD →/←" doc.description = "previous WORD; e.g. contiguous non-whitespace region" args.unit = "BigWord" args.value = "{{-count || -1}}" @@ -1043,9 +1043,9 @@ key = "g 0" priority = 1 doc.name = "sec →" doc.description = "next section" -doc.combinedName = "sec →/←" -doc.combinedDescription = "next/previous section" -doc.combinedKey = "0/9" +doc.combined.name = "sec →/←" +doc.combined.description = "next/previous section" +doc.combined.key = "0/9" args.unit = "section" args.value = "{{count || 1}}" @@ -1055,7 +1055,7 @@ key = "g 9" priority = 1 doc.name = "sec ←" doc.description = "previous section" -doc.combinedName = "sec →/←" +doc.combined.name = "sec →/←" args.unit = "section" args.value = "{{-(count || 1)}}" @@ -1081,9 +1081,9 @@ doc.name = "go to" priority = 1 doc.description = "go to the definition of symbol under cursor" key = "g d" -doc.combinedName = "go to (aside)" -doc.combinedKey = "(shift+)d" -doc.combinedDescription = "go to the definition of symbol (in an editor to the side)" +doc.combined.name = "go to (aside)" +doc.combined.key = "(shift+)d" +doc.combined.description = "go to the definition of symbol (in an editor to the side)" command = "editor.action.revealDefinition" [[bind]] @@ -1092,7 +1092,7 @@ doc.name = "go to, aside" priority = 1 doc.description = "go to the definition of symbol under cursor in an editor to the side" key = "g shift+d" -doc.combinedName = "go to (aside)" +doc.combined.name = "go to (aside)" command = "editor.action.revealDefinitionAside" [[bind]] @@ -1106,7 +1106,7 @@ command = "extension.openFileFromPath" default = "{{bind.edit_motion}}" key = "g c" doc.name = "cell →" -doc.combinedName = "cell →/←" +doc.combined.name = "cell →/←" command = "runCommands" args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] doc.description = "previous jupyter notebook cell" @@ -1115,7 +1115,7 @@ doc.description = "previous jupyter notebook cell" default = "{{bind.edit_motion}}" key = "g shift+c" doc.name = "cell ←" -doc.combinedName = "cell →/←" +doc.combined.name = "cell →/←" doc.description = "previous jupyter notebook cell" command = "runCommands" args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] @@ -1156,9 +1156,9 @@ default = "{{bind.edit_motion_match_obj}}" key = "m w" doc.name = "around subwrd →" doc.description = "(camel/snake case)" -doc.combinedName = "around subwrd ←/→" -doc.combinedDescription = "(camel/snake case)" -doc.combinedKey = "w/b" +doc.combined.name = "around subwrd ←/→" +doc.combined.description = "(camel/snake case)" +doc.combined.key = "w/b" args.unit = "subword" args.value = "{{count || 1}}" @@ -1167,7 +1167,7 @@ default = "{{bind.edit_motion_match_obj}}" key = "m b" doc.name = "around subwrd ←" doc.description = "(camel/snake case)" -doc.combinedName = "around subwrd ←/→" +doc.combined.name = "around subwrd ←/→" args.unit = "subword" args.value = "{{-count || -1}}" @@ -1175,8 +1175,8 @@ args.value = "{{-count || -1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+w" doc.name = "ard word →" -doc.combinedName = "around word →/←" -doc.combinedKey = "shift+w/b" +doc.combined.name = "around word →/←" +doc.combined.key = "shift+w/b" args.unit = "word" args.value = "{{count || 1}}" @@ -1184,7 +1184,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+b" doc.name = "ard word ←" -doc.combinedName = "around word →/←" +doc.combined.name = "around word →/←" args.unit = "word" args.value = "{{-count || -1}}" @@ -1192,8 +1192,8 @@ args.value = "{{-count || -1}}" default = "{{bind.edit_motion_match_obj}}" key = "m e" doc.name = "in subwrd" -doc.combinedName = "in → subword/word" -doc.combinedKey = "e/shift+e" +doc.combined.name = "in → subword/word" +doc.combined.key = "e/shift+e" args.unit = "subident" args.boundary = "both" args.value = "{{count || 1}}" @@ -1202,7 +1202,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+e" doc.name = "in word" -doc.combinedName = "in → subword/word" +doc.combined.name = "in → subword/word" args.unit = "word" args.boundary = "both" args.value = "{{count || 1}}" @@ -1211,8 +1211,8 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m p" doc.name = "in parag. →" -doc.combinedName = "in paragraph →/←" -doc.combinedKey = "p/o" +doc.combined.name = "in paragraph →/←" +doc.combined.key = "p/o" args.boundary = "both" args.unit = "paragraph" args.value = "{{count || 1}}" @@ -1221,7 +1221,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m o" doc.name = "in parag. ←" -doc.combinedName = "in paragraph →/←" +doc.combined.name = "in paragraph →/←" args.unit = "paragraph" args.boundary = "both" args.value = "{{-(count || 1)}}" @@ -1230,8 +1230,8 @@ args.value = "{{-(count || 1)}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+p" doc.name = "arn parag. →" -doc.combinedName = "around paragraph →/←" -doc.combinedKey = "shift+p/shift+o" +doc.combined.name = "around paragraph →/←" +doc.combined.key = "shift+p/shift+o" args.unit = "paragraph" args.value = "{{count || 1}}" @@ -1239,7 +1239,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+o" doc.name = "arn parag. ←" -doc.combinedName = "around paragraph →/←" +doc.combined.name = "around paragraph →/←" args.unit = "paragraph" args.value = "{{-(count || 1)}}" @@ -1247,8 +1247,8 @@ args.value = "{{-(count || 1)}}" default = "{{bind.edit_motion_match_obj}}" key = "m 0" doc.name = "arn subsec →" -doc.combinedName = "around subsection →/←" -doc.combinedKey = "0/shift+0" +doc.combined.name = "around subsection →/←" +doc.combined.key = "0/shift+0" args.unit = "subsection" args.value = "{{count || 1}}" @@ -1256,7 +1256,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+0" doc.name = "arn subsec ←" -doc.combinedName = "around subsection →/←" +doc.combined.name = "around subsection →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" @@ -1264,8 +1264,8 @@ args.value = "{{-(count || 1)}}" default = "{{bind.edit_motion_match_obj}}" key = "m 9" doc.name = "in subsec →" -doc.combinedName = "in subsection →/←" -doc.combinedKey = "9/shift+9" +doc.combined.name = "in subsection →/←" +doc.combined.key = "9/shift+9" args.unit = "subsection" args.value = "{{count || 1}}" @@ -1273,7 +1273,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m shift+9" doc.name = "in subsec ←" -doc.combinedName = "in subsection →/←" +doc.combined.name = "in subsection →/←" args.unit = "subsection" args.value = "{{-(count || 1)}}" @@ -1288,8 +1288,8 @@ command = "master-key.prefix" default = "{{bind.edit_motion_match_obj}}" key = "m g 0" doc.name = "section →" -doc.combinedName = "section →/←" -doc.combinedKey = "0/9" +doc.combined.name = "section →/←" +doc.combined.key = "0/9" args.unit = "section" args.value = "{{count || 1}}" @@ -1297,7 +1297,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m g 9" doc.name = "section ←" -doc.combinedName = "section →/←" +doc.combined.name = "section →/←" args.unit = "section" args.value = "{{-(count || 1)}}" @@ -1305,8 +1305,8 @@ args.value = "{{-(count || 1)}}" default = "{{bind.edit_motion_match_obj}}" key = "m g w" doc.name = "around WORD →" -doc.combinedName = "around WORD →/←" -doc.combinedKey = "w/b" +doc.combined.name = "around WORD →/←" +doc.combined.key = "w/b" args.unit = "BigWord" args.value = "{{count || 1}}" @@ -1314,7 +1314,7 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion_match_obj}}" key = "m g b" doc.name = "around WORD ←" -doc.combinedName = "around WORD →/←" +doc.combined.name = "around WORD →/←" args.unit = "BigWord" args.value = "{{-(count || 1)}}" @@ -1330,9 +1330,9 @@ args.value = "{{count || 1}}" default = "{{bind.edit_motion}}" key = "m [" doc.name = "in parens" -doc.combinedName = "in/arnd parens" -doc.combinedKey = "[/shift+[" -doc.combinedDescription = """ +doc.combined.name = "in/arnd parens" +doc.combined.key = "[/shift+[" +doc.combined.description = """ expand inside/around parens/brackets/braces and their contents; repeated calls to this command will seek out larger and larger scopes """ @@ -1346,7 +1346,7 @@ command = "selection-utilities.expandWithinBrackets" default = "{{bind.edit_motion}}" key = "m shift+[" doc.name = "arnd parens" -doc.combinedName = "in/arnd parens" +doc.combined.name = "in/arnd parens" doc.description = """ expand inside parens/brackets/braces and their contents; repeated calls to this command will seek out larger and larger scopes @@ -1361,9 +1361,9 @@ doc.description = """ select within current quotes; repeated calls to this command will seek out larger and larger scopes """ -doc.combinedName = "in/arnd quotes" -doc.combinedKey = "'/shift+'" -doc.combinedDescription = """ +doc.combined.name = "in/arnd quotes" +doc.combined.key = "'/shift+'" +doc.combined.description = """ select within/around current quotes; repeated calls to this command will seek out larger and larger scopes """ @@ -1373,7 +1373,7 @@ command = "bracketeer.selectQuotesContent" default = "{{bind.edit_motion}}" key = "m shift+'" doc.name = "around quotes" -doc.combinedName = "in/arnd quotes" +doc.combined.name = "in/arnd quotes" doc.description = """ select around current quotes; repeated calls to this command will seek out larger and larger scopes @@ -1386,16 +1386,16 @@ default = "{{bind.edit_motion}}" key = "m shift+." doc.name = "in <>" doc.description = "text inside angle brackets" -doc.combinedName = "in <> / in ><" -doc.combinedKey = "shift+. / shift+," -doc.combinedDescription = "text inside angle brackets / pairs (e.g. text in text)" +doc.combined.name = "in <> / in ><" +doc.combined.key = "shift+. / shift+," +doc.combined.description = "text inside angle brackets / pairs (e.g. text in text)" command = "extension.selectAngleBrackets" [[bind]] default = "{{bind.edit_motion}}" key = "m shift+," doc.name = "in ><" -doc.combinedName = "in <> / in ><" +doc.combined.name = "in <> / in ><" doc.description = "text inside tag pairs (e.g. text)" command = "extension.selectInTag" @@ -1404,9 +1404,9 @@ default = "{{bind.edit_motion}}" key = "m i" doc.name = "in indent" doc.description = "all text at the same indentation level" -doc.combinedName = "in/arnd" -doc.combinedKey = "space/shift+space" -doc.combinedDescription = """ +doc.combined.name = "in/arnd" +doc.combined.key = "space/shift+space" +doc.combined.description = """ all text at the same indentation level / all indentation along with the line above and below this (ala c-like syntax) """ @@ -1420,7 +1420,7 @@ doc.description = """ all text at the same indentation level along with the line above and below this (ala c-like syntax) """ -doc.combinedName = "in/arnd" +doc.combined.name = "in/arnd" command = "vscode-select-by-indent.select-outer" [[bind]] @@ -1430,7 +1430,7 @@ doc.name = "indent+top" doc.description = """ all text at the same indentation level and the line just above it (ala python syntax) """ -doc.combinedName = "in/arnd" +doc.combined.name = "in/arnd" command = "vscode-select-by-indent.select-outer-top-only" [[bind]] @@ -1443,7 +1443,7 @@ command = "jupyter.selectCell" [[bind]] default = "{{bind.edit_motion}}" doc.name = "between pair" -doc.combinedDescription = """ +doc.combined.description = """ Select between pairs of the same N characters (t) or distinct sets of N characters (s), where N is the count. Examples: 2mt'' would search for a string between `''` and `''`. @@ -1451,8 +1451,8 @@ characters (s), where N is the count. Examples: """ key = "m t" command = "runCommands" -doc.combinedName = "between pair/two" -doc.combinedKey = "t/s" +doc.combined.name = "between pair/two" +doc.combined.key = "t/s" doc.description = """ Select between pairs of the same N characters, where N is the count. Example: 2mt'' would search for a string between '' and ''. @@ -1475,7 +1475,7 @@ Select between two different sets of N characters, where N is the count e.g. 2ms,,.. would search for a string between ,, and .. """ key = "m s" -doc.combinedName = "between pair/two" +doc.combined.name = "between pair/two" command = "runCommands" [[bind.args.commands]] @@ -1648,9 +1648,9 @@ default = "{{bind.edit_action}}" key = "p" doc.name = "paste after" doc.description = "Paste clipboard after the cursor/selection" -doc.combinedName = "paste before/after/in" -doc.combinedDescription = "Paste clipboard before/after/at the cursor/selection" -doc.combinedKey = "p/shift+p/ctrl+p" +doc.combined.name = "paste before/after/in" +doc.combined.description = "Paste clipboard before/after/at the cursor/selection" +doc.combined.key = "p/shift+p/ctrl+p" when = "editorHasSelection" command = "runCommands" args.commands = [ @@ -1663,7 +1663,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "p" doc.name = "paste after" -doc.combinedName = "paste before/after/in" +doc.combined.name = "paste before/after/in" when = "!editorHasSelection" command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] @@ -1674,7 +1674,7 @@ key = "ctrl+p" when = "!suggestWidgetVisible" mode = '{{not_modes(["normal", "insert"]}}' doc.name = "paste in" -doc.combinedName = "paste before/after/in" +doc.combined.name = "paste before/after/in" doc.description = "Paste clipboard at location" command = "editor.action.clipboardPasteAction" @@ -1682,7 +1682,7 @@ command = "editor.action.clipboardPasteAction" default = "{{bind.edit_action}}" key = "shift+p" doc.name = "paste before" -doc.combinedName = "paste before/after" +doc.combined.name = "paste before/after" doc.description = "Paste before the cursor/selection" when = "editorHasSelection" command = "runCommands" @@ -1695,7 +1695,7 @@ args.commands = [ [[bind]] default = "{{bind.edit_action}}" key = "shift+p" -doc.combinedName = "paste before/after" +doc.combined.name = "paste before/after" when = "!editorHasSelection" command = "runCommands" args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] @@ -2016,8 +2016,8 @@ command = "master-key.prefix" [[bind]] default = "{{bind.edit_action}}" doc.name = "paste after line" -doc.combinedName = "paste after/before line" -doc.combinedKey = "p/shift+p" +doc.combined.name = "paste after/before line" +doc.combined.key = "p/shift+p" doc.description = "Paste text after current line" priority = 2 key = "space p" @@ -2033,7 +2033,7 @@ args.commands = [ default = "{{bind.edit_action}}" priority = 2 doc.name = "paste before line" -doc.combinedName = "paste after/before line" +doc.combined.name = "paste after/before line" doc.description = "Paste text before current line" key = "space shift+p" command = "runCommands" @@ -2048,9 +2048,9 @@ args.commands = [ default = "{{bind.edit_action}}" priority = 2 doc.name = "add line below" -doc.combinedName = "add line below/above" -doc.combinedDescription = "open a line below/above current line" -doc.combinedKey = "o/shift+o" +doc.combined.name = "add line below/above" +doc.combined.description = "open a line below/above current line" +doc.combined.key = "o/shift+o" doc.description = "open a line below current line" key = "space o" command = "editor.action.insertLineAfter" @@ -2059,7 +2059,7 @@ command = "editor.action.insertLineAfter" default = "{{bind.edit_action}}" doc.name = "add line above" priority = 2 -doc.combinedName = "add line below/above" +doc.combined.name = "add line below/above" doc.description = "open a line above current line" key = "space shift+o" command = "editor.action.insertLineBefore" @@ -2070,9 +2070,9 @@ doc.name = 'sym insert' doc.description = "Insert a character pair around a character" priority = 1 key = "space i" -doc.combinedName = "sym insert (mode)" -doc.combinedDescription = "Insert characters around pair (switching to syminster mode until hitting again)" -doc.combinedKey = "i/shift+i" +doc.combined.name = "sym insert (mode)" +doc.combined.description = "Insert characters around pair (switching to syminster mode until hitting again)" +doc.combined.key = "i/shift+i" command = "runCommands" [[bind.args.commands]] @@ -2096,16 +2096,16 @@ command = "selection-utilities.trimWhitespace" default = "{{bind.edit_action}}" key = "space w" doc.name = "wrap p" -doc.combinedName = "wrap/join lines" +doc.combined.name = "wrap/join lines" doc.description = "wrap paragraph text, preserving commenting" -doc.combinedDescription = "wrap paragraph text, preserving commenting / join lines together" -doc.combinedKey = "w/j" +doc.combined.description = "wrap paragraph text, preserving commenting / join lines together" +doc.combined.key = "w/j" command = "rewrap.rewrapComment" [[bind]] default = "{{bind.edit_action}}" doc.name = 'join' -doc.combinedName = "wrap/join lines" +doc.combined.name = "wrap/join lines" doc.description = "Remove newline between current and next line" key = "space j" mode = '{{not_modes(["normal", "selectedit"]}}' @@ -2115,7 +2115,7 @@ args.commands = ["{{command.selectLinesDown}}", 'editor.action.joinLines'] [[bind]] default = "{{bind.edit_action}}" -doc.combinedName = "wrap/join lines" +doc.combined.name = "wrap/join lines" doc.name = 'join' doc.description = "Remove newline between current and next line" mode = '{{not_modes(["normal", "selectedit"]}}' @@ -2126,7 +2126,7 @@ command = "editor.action.joinLines" default = "{{bind.edit_action}}" key = "space f" doc.name = "format" -doc.combinedName = "format / format document" +doc.combined.name = "format / format document" when = "master-key.count < 1" command = "editor.action.formatSelection" @@ -2138,9 +2138,9 @@ args.commands = [ ] default = "{{bind.edit_action}}" key = "space f" -doc.combinedName = "format / format document" -doc.combinedKey = "f/shift+f" -doc.combinedDescription = "Format selection / document" +doc.combined.name = "format / format document" +doc.combined.key = "f/shift+f" +doc.combined.description = "Format selection / document" doc.name = "format" doc.description = "Format sel" when = "master-key.count >= 1" @@ -2150,7 +2150,7 @@ command = "runCommands" default = "{{bind.edit_action}}" key = "space shift+f" doc.name = "format doc" -doc.combinedName = "format / format document" +doc.combined.name = "format / format document" command = "editor.action.formatDocument" [[bind]] @@ -2198,7 +2198,7 @@ command = "bracketeer.swapQuotes" [[bind]] default = "{{bind.edit_action}}" key = "space /" -doc.combinedName = "(block) comment" +doc.combined.name = "(block) comment" when = "master-key.count < 1" command = "editor.action.commentLine" @@ -2207,9 +2207,9 @@ args.commands = ["{{command.selectLinesDown}}", "editor.action.commentLine"] default = "{{bind.edit_action}}" key = "space /" doc.name = "comment lines" -doc.combinedName = "(block) comment" -doc.combinedDescription = "Toggle (block) comment" -doc.combinedKey = "(shift+)/" +doc.combined.name = "(block) comment" +doc.combined.description = "Toggle (block) comment" +doc.combined.key = "(shift+)/" doc.description = "select next comment" when = "master-key.count >= 1" command = "runCommands" @@ -2218,7 +2218,7 @@ command = "runCommands" default = "{{bind.edit_action}}" key = "space shift+/" when = "master-key.count < 1" -doc.combinedName = "(block) comment" +doc.combined.name = "(block) comment" command = "editor.action.blockComment" [[bind]] @@ -2230,7 +2230,7 @@ args.commands = [ default = "{{bind.edit_action}}" key = "space shift+/" doc.name = "block comment lines" -doc.combinedName = "(block) comment" +doc.combined.name = "(block) comment" doc.description = "select previous comment" when = "master-key.count >= 1" command = "runCommands" @@ -2238,9 +2238,9 @@ command = "runCommands" [[bind]] default = "{{bind.edit_action}}" doc.name = 'inc all #' -doc.combinedName = "inc/dec all #" -doc.combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" -doc.combinedKey = "=/shift+=" +doc.combined.name = "inc/dec all #" +doc.combined.description = "Increment/decrement selected numbers; increment/decrement increases per selection" +doc.combined.key = "=/shift+=" doc.description = "Increment selected numbers; increment increases per selection" key = "space =" command = "selection-utilities.incrementNumberPerSelection" @@ -2248,7 +2248,7 @@ command = "selection-utilities.incrementNumberPerSelection" [[bind]] default = "{{bind.edit_action}}" doc.name = 'dec all #' -doc.combinedName = "inc/dec all #" +doc.combined.name = "inc/dec all #" doc.description = "Decrement selected numbers; decrement increases per selection" key = "space shift+=" command = "selection-utilities.decrementNumberPerSelection" @@ -2427,10 +2427,10 @@ command = "master-key.prefix" [[bind]] default = "{{bind.util}}" doc.name = "pull" -doc.combinedName = "push/pull" +doc.combined.name = "push/pull" doc.description = "pull changes from remote" -doc.combinedDescription = "pull from/push to remote" -doc.combinedKey = "p/shift+p" +doc.combined.description = "pull from/push to remote" +doc.combined.key = "p/shift+p" key = "tab g p" command = "git.pull" @@ -2444,17 +2444,17 @@ command = "git.push" [[bind]] default = "{{bind.util}}" doc.name = "checkout" -doc.combinedName = "commit/checkout" +doc.combined.name = "commit/checkout" doc.description = "commit changes" -doc.combinedDescription = "commit/checkout git changes" -doc.combinedKey = "c/shift+c" +doc.combined.description = "commit/checkout git changes" +doc.combined.key = "c/shift+c" key = "tab g c" command = "git.commit" [[bind]] default = "{{bind.util}}" doc.name = "checkout" -doc.combinedName = "commit/checkout" +doc.combined.name = "commit/checkout" doc.description = "checkout changes" key = "tab g shift+c" command = "git.checkout" @@ -2506,16 +2506,16 @@ command = "workbench.action.openRecent" default = "{{bind.util}}" doc.name = "hover" doc.description = "show the hover view" -doc.combinedName = "(debug) hover" -doc.combinedDescription = "show the (debug) hover view" -doc.combinedKey = "(shift+)h" +doc.combined.name = "(debug) hover" +doc.combined.description = "show the (debug) hover view" +doc.combined.key = "(shift+)h" key = "tab h" command = "editor.action.showHover" [[bind]] default = "{{bind.util}}" doc.name = "debug hover" -doc.combinedName = "(debug) hover" +doc.combined.name = "(debug) hover" doc.description = "show the debug hover view" key = "tab shift+h" command = "editor.debug.action.showDebugHover" @@ -2523,19 +2523,19 @@ command = "editor.debug.action.showDebugHover" [[bind]] default = "{{bind.util}}" doc.name = "add mark" -doc.combinedName = "add mark / mark..." +doc.combined.name = "add mark / mark..." doc.description = "toggle bookmark at given line" -doc.combinedDescription = """ +doc.combined.description = """ toggle bookmark at given line / bookmark related commands """ key = "tab shift+m" -doc.combinedKey = "shift+m / m" +doc.combined.key = "shift+m / m" command = "vsc-labeled-bookmarks.toggleBookmark" [[bind]] default = "{{bind.util}}" doc.name = "mark" -doc.combinedName = "add mark / mark..." +doc.combined.name = "add mark / mark..." doc.description = "bookmark related commands" key = "tab m" command = "master-key.prefix" @@ -2544,16 +2544,16 @@ command = "master-key.prefix" default = "{{bind.util}}" doc.name = "mark ↓" doc.description = "move to next bookmark" -doc.combinedName = "mark ↓/↑" -doc.combinedDescription = "move to next/previous bookmark" -doc.combinedKey = "j/k" +doc.combined.name = "mark ↓/↑" +doc.combined.description = "move to next/previous bookmark" +doc.combined.key = "j/k" key = "tab m j" when = "!master-key.val.select && !editorHasSelection" command = "vsc-labeled-bookmarks.navigateToNextBookmark" [[bind]] default = "{{bind.util}}" -doc.combinedName = "mark ↓/↑" +doc.combined.name = "mark ↓/↑" key = "tab m j" when = "master-key.val.select || editorHasSelection" command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" @@ -2561,7 +2561,7 @@ command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" [[bind]] default = "{{bind.util}}" doc.name = "mark ↑" -doc.combinedName = "mark ↓/↑" +doc.combined.name = "mark ↓/↑" doc.description = "move to previous bookmark" key = "tab m k" when = "!master-key.val.select && !editorHasSelection" @@ -2570,7 +2570,7 @@ command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" [[bind]] default = "{{bind.util}}" doc.name = "mark ↑" -doc.combinedName = "mark ↓/↑" +doc.combined.name = "mark ↓/↑" doc.description = "move to previous bookmark" key = "tab m k" when = "master-key.val.select || editorHasSelection" @@ -2597,9 +2597,9 @@ command = "vsc-labeled-bookmarks.navigateToBookmark" [[bind]] default = "{{bind.util}}" doc.name = "error →" -doc.combinedName = "error →/←" -doc.combinedDescription = "move to next/previous error" -doc.combinedKey = "e/shift+e" +doc.combined.name = "error →/←" +doc.combined.description = "move to next/previous error" +doc.combined.key = "e/shift+e" doc.description = """ move to next error """ @@ -2609,7 +2609,7 @@ command = "editor.action.marker.next" [[bind]] default = "{{bind.edit_motion}}" doc.name = "error ←" -doc.combinedName = "error →/←" +doc.combined.name = "error →/←" doc.description = """ move to previous error """ @@ -2619,9 +2619,9 @@ command = "editor.action.marker.prev" [[bind]] default = "{{bind.edit_motion}}" doc.name = "diff →" -doc.combinedName = "diff →/←" -doc.combinedDescription = "move to and show next/previous diff" -doc.combinedKey = "c/shift+c" +doc.combined.name = "diff →/←" +doc.combined.description = "move to and show next/previous diff" +doc.combined.key = "c/shift+c" doc.description = """ move to and show next diff """ @@ -2631,7 +2631,7 @@ command = "editor.action.dirtydiff.next" [[bind]] default = "{{bind.edit_motion}}" doc.name = "diff ←" -doc.combinedName = "diff →/←" +doc.combined.name = "diff →/←" doc.description = """ move to and show previous diff """ @@ -2641,9 +2641,9 @@ command = "editor.action.dirtydiff.previous" [[bind]] default = "{{bind.edit_motion}}" doc.name = "change →" -doc.combinedName = "change →/←" -doc.combinedDescription = "move to next/previous file change" -doc.combinedKey = "d/shift+d" +doc.combined.name = "change →/←" +doc.combined.description = "move to next/previous file change" +doc.combined.key = "d/shift+d" doc.description = """ move to next file change """ @@ -2653,7 +2653,7 @@ command = "workbench.action.editor.nextChange" [[bind]] default = "{{bind.edit_motion}}" doc.name = "change ←" -doc.combinedName = "change →/←" +doc.combined.name = "change →/←" doc.description = """ move to previous change """ @@ -2695,17 +2695,17 @@ command = "workbench.action.toggleEditorGroupLayout" [[bind]] default = "{{bind.window}}" doc.name = "next window" -doc.combinedName = "next/previous window" +doc.combined.name = "next/previous window" doc.description = "move to next window" -doc.combinedDescription = "move to next/prev window" +doc.combined.description = "move to next/prev window" key = "tab ]" -doc.combinedKey = "]/[" +doc.combined.key = "]/[" command = "workbench.action.focusNextGroup" [[bind]] default = "{{bind.window}}" doc.name = "prev window" -doc.combinedName = "next/previous window" +doc.combined.name = "next/previous window" doc.description = "move to previous window" key = "tab [" command = "workbench.action.focusPreviousGroup" @@ -2713,9 +2713,9 @@ command = "workbench.action.focusPreviousGroup" [[bind]] default = "{{bind.window}}" doc.name = "move →" -doc.combinedName = "move →/←" -doc.combinedDescription = "move editor to window left/right" -doc.combinedKey = "l/h" +doc.combined.name = "move →/←" +doc.combined.description = "move editor to window left/right" +doc.combined.key = "l/h" doc.description = "move editor to window to left" key = "tab w l" command = "workbench.action.moveEditorToRightGroup" @@ -2723,7 +2723,7 @@ command = "workbench.action.moveEditorToRightGroup" [[bind]] default = "{{bind.window}}" doc.name = "←" -doc.combinedName = "move →/←" +doc.combined.name = "move →/←" doc.description = "move editor to window to left" key = "tab w h" command = "workbench.action.moveEditorToLeftGroup" @@ -2731,9 +2731,9 @@ command = "workbench.action.moveEditorToLeftGroup" [[bind]] default = "{{bind.window}}" doc.name = "↓" -doc.combinedName = "move ↓/↑" -doc.combinedDescription = "move editor to window above/below" -doc.combinedKey = "j/k" +doc.combined.name = "move ↓/↑" +doc.combined.description = "move editor to window above/below" +doc.combined.key = "j/k" doc.description = "move editor to window below" key = "tab w j" command = "workbench.action.moveEditorToBelowGroup" @@ -2741,7 +2741,7 @@ command = "workbench.action.moveEditorToBelowGroup" [[bind]] default = "{{bind.window}}" doc.name = "↑" -doc.combinedName = "move ↓/↑" +doc.combined.name = "move ↓/↑" doc.description = "move editor to window above" key = "tab w k" command = "workbench.action.moveEditorToAboveGroup" @@ -2756,9 +2756,9 @@ command = "master-key.prefix" [[bind]] default = "{{bind.window}}" doc.name = "move →" -doc.combinedName = "split →/←" -doc.combinedDescription = "move editor to window left/right" -doc.combinedKey = "l/h" +doc.combined.name = "split →/←" +doc.combined.description = "move editor to window left/right" +doc.combined.key = "l/h" doc.description = "split editor to window to left" key = "tab w s l" command = "workbench.action.splitEditorRight" @@ -2766,7 +2766,7 @@ command = "workbench.action.splitEditorRight" [[bind]] default = "{{bind.window}}" doc.name = "←" -doc.combinedName = "split →/←" +doc.combined.name = "split →/←" doc.description = "split editor to window to left" key = "tab w s h" command = "workbench.action.splitEditorLeft" @@ -2774,9 +2774,9 @@ command = "workbench.action.splitEditorLeft" [[bind]] default = "{{bind.window}}" doc.name = "↓" -doc.combinedName = "split ↓/↑" -doc.combinedDescription = "split editor to window above/below" -doc.combinedKey = "j/k" +doc.combined.name = "split ↓/↑" +doc.combined.description = "split editor to window above/below" +doc.combined.key = "j/k" doc.description = "split editor to window below" key = "tab w s j" command = "workbench.action.splitEditorDown" @@ -2784,9 +2784,9 @@ command = "workbench.action.splitEditorDown" [[bind]] default = "{{bind.window}}" doc.name = "↑" -doc.combinedName = "split ↓/↑" -doc.combinedDescription = "split editor to window above/below" -doc.combinedKey = "j/k" +doc.combined.name = "split ↓/↑" +doc.combined.description = "split editor to window above/below" +doc.combined.key = "j/k" doc.description = "split editor to window below" key = "tab w s k" command = "workbench.action.splitEditorUp" @@ -2817,16 +2817,16 @@ default = "{{bind.window}}" doc.name = "curs. win top" doc.description = "center window so that primary cursor is at the top" key = "tab k" -doc.combinedName = "center window top/bottom" -doc.combinedDescription = "center window so that primary cursor is at the top/bottom" -doc.combinedKey = "k/j" +doc.combined.name = "center window top/bottom" +doc.combined.description = "center window so that primary cursor is at the top/bottom" +doc.combined.key = "k/j" command = "selection-utilities.revealActive" args.at = "top" [[bind]] default = "{{bind.window}}" doc.name = "curs. win bot" -doc.combinedName = "center window top/bottom" +doc.combined.name = "center window top/bottom" doc.description = "center window so that primary cursor is at the bottom" key = "tab j" command = "selection-utilities.revealActive" @@ -2839,17 +2839,17 @@ args.at = "bottom" [[bind]] default = "{{bind.util}}" doc.name = "breakpt." -doc.combinedName = "breakpt / debug..." -doc.combinedKey = "shift+b/b" +doc.combined.name = "breakpt / debug..." +doc.combined.key = "shift+b/b" doc.description = "toggle debug breakpoint" -doc.combinedDescription = "toggle debug breakpoint / debug related commands..." +doc.combined.description = "toggle debug breakpoint / debug related commands..." key = "tab shift+b" command = "editor.debug.action.toggleBreakpoint" [[bind]] default = "{{bind.util}}" doc.name = "debug..." -doc.combinedName = "breakpt / debug..." +doc.combined.name = "breakpt / debug..." doc.description = "assorted debugging actions" key = "tab b" command = "master-key.prefix" @@ -2925,9 +2925,9 @@ mode = "normal" [[bind]] default = "{{bind.edit_select_edit}}" key = "shift+'" -doc.combinedName = "rm cursors" -doc.combinedKey = "shift/ctrl+'" -doc.combinedDescription = "Delete all selections and return to normal (multiple key variants)" +doc.combined.name = "rm cursors" +doc.combined.key = "shift/ctrl+'" +doc.combined.description = "Delete all selections and return to normal (multiple key variants)" doc.name = "del. cursors" doc.description = "Delete all selections and return to normal" command = "runCommands" @@ -2939,7 +2939,7 @@ default = "{{bind.edit_select_edit}}" key = "ctrl+'" mode = '{{not_modes(["insert", "selectedit", "normal"]}}' doc.name = "rm cursors" -doc.combinedName = "rm cursors" +doc.combined.name = "rm cursors" doc.description = "Delete all selections and return to normal" command = "runCommands" args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] @@ -2954,18 +2954,18 @@ command = "master-key.enterNormal" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "add →" -doc.combinedName = "add →/←" +doc.combined.name = "add →/←" doc.description = "add cursor at the next match to the primary cursor's text" -doc.combinedDescription = "add cursor at the next/previous match to the primary cursor's text" +doc.combined.description = "add cursor at the next/previous match to the primary cursor's text" key = "l" -doc.combinedKey = "l/h" +doc.combined.key = "l/h" repeat = "{{count}}" command = "selection-utilities.addNext" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "add ←" -doc.combinedName = "add →/←" +doc.combined.name = "add →/←" doc.description = "add cursor at the previous match to the primary cursor's text" key = "h" command = "selection-utilities.addPrev" @@ -2974,18 +2974,18 @@ repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "skip →" -doc.combinedName = "skip →/←" +doc.combined.name = "skip →/←" doc.description = "move primary cursor to the next match of the primary cursor's text" -doc.combinedDescription = "move primary cursor to the next/previous match of the primary cursor's text" +doc.combined.description = "move primary cursor to the next/previous match of the primary cursor's text" key = "shift+l" -doc.combinedKey = "shift+l/h" +doc.combined.key = "shift+l/h" command = "selection-utilities.skipNext" repeat = "{{count}}" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "skip ←" -doc.combinedName = "skip →/←" +doc.combined.name = "skip →/←" doc.description = "move primary cursor to the previous match of the primary cursor's text" key = "shift+h" command = "selection-utilities.skipPrev" @@ -3008,24 +3008,24 @@ command = "selection-utilities.alignSelectionsRight" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "→ sel" -doc.combinedName = "→/← sel" +doc.combined.name = "→/← sel" doc.description = """ make the next selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections """ -doc.combinedDescription = """ +doc.combined.description = """ make the next/previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections """ key = "j" -doc.combinedKey = "j/l" +doc.combined.key = "j/l" command = "selection-utilities.movePrimaryRight" repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "← sel" -doc.combinedName = "→/← sel" +doc.combined.name = "→/← sel" doc.description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" key = "k" command = "selection-utilities.movePrimaryLeft" @@ -3034,20 +3034,20 @@ repeat = '{{count}}' [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "insert ↑" -doc.combinedName = "insert ↑/↓" +doc.combined.name = "insert ↑/↓" doc.description = """ insert cursor on line above """ -doc.combinedDescription = "insert cursor on line above/below" +doc.combined.description = "insert cursor on line above/below" key = "shift+k" -doc.combinedKey = "shift+k/j" +doc.combined.key = "shift+k/j" command = "editor.action.insertCursorAbove" repeat = "{{count}}" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "insert sel ↓" -doc.combinedName = "insert ↑/↓" +doc.combined.name = "insert ↑/↓" doc.description = """ insert cursor on line below """ @@ -3058,9 +3058,9 @@ repeat = "{{count-1}}" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "del. primary" -doc.combinedName = "del. primary/others" +doc.combined.name = "del. primary/others" doc.description = "remove the primary selection" -doc.combinedDescription = """ +doc.combined.description = """ Remove either the primary selection or all selections. Return to normal mode if all selections are deleted. """ @@ -3233,16 +3233,16 @@ command = "selection-utilities.excludeByRegex" default = "{{bind.edit_select_edit}}" key = "o" doc.name = "active to front" -doc.combinedKey = "o/shift+o" -doc.combinedName = "active to start/end" -doc.combinedDescription = "move cursor to start/end of selection" +doc.combined.key = "o/shift+o" +doc.combined.name = "active to start/end" +doc.combined.description = "move cursor to start/end of selection" doc.description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_select_edit}}" doc.name = "active to end" -doc.combinedName = "active to start/end" +doc.combined.name = "active to start/end" doc.description = "move cursor to back of selection" key = "shift+o" command = "selection-utilities.activeAtStart" @@ -3306,7 +3306,7 @@ the selection """ mode = "normal" key = "space shift+i" -doc.combinedName = "sym insert (mode)" +doc.combined.name = "sym insert (mode)" command = "master-key.setMode" args.value = "syminsert" @@ -3382,16 +3382,16 @@ args.count = "{{count}}" default = "{{bind.edit_motion_symmetric}}" key = "o" doc.name = "active to front" -doc.combinedKey = "o/shift+o" -doc.combinedName = "active to start/end" -doc.combinedDescription = "move cursor to start/end of selection" +doc.combined.key = "o/shift+o" +doc.combined.name = "active to start/end" +doc.combined.description = "move cursor to start/end of selection" doc.description = "move cursor to start of selection" command = "selection-utilities.activeAtEnd" [[bind]] default = "{{bind.edit_motion_symmetric}}" doc.name = "active to end" -doc.combinedName = "active to start/end" +doc.combined.name = "active to start/end" doc.description = "move cursor to back of selection" key = "shift+o" command = "selection-utilities.activeAtStart" diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index a772f84d..5ae43a4c 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -384,19 +384,15 @@ pub struct BindingDocInput { /// @forBindingField bind /// @order 10 /// - /// - `combinedName/combinedKey/combinedDescription`: in the suggestion palette and - /// textual documentation, keys that have the same `combinedName` will be - /// represented as single entry, using the `combinedKey` and `combinedDescription` - /// instead of `key` and `description`. The `combinedKey` for a multi-key sequence - /// should only include the suffix key. You need only define `combinedKey` and - /// `combinedDescription` once across keys that share the same `combinedName` + /// - `combined.name/combined.key/combined.description`: in the suggestion palette and + /// textual documentation, keys that have the same `combined.name` will be + /// represented as single entry, using the `combined.key` and `combined.description` + /// instead of `key` and `description`. The `combined.key` for a multi-key sequence + /// should only include the suffix key. You need only define `combined.key` and + /// `combined.description` once across keys that share the same `combined.name` /// entry. #[serde(default)] - pub combinedName: Option>>, - #[serde(default)] - pub combinedKey: Option>>, - #[serde(default)] - pub combinedDescription: Option>>, + pub combined: Option, /// @forBindingField bind /// @order 10 @@ -408,6 +404,17 @@ pub struct BindingDocInput { pub kind: Option>>, } +#[allow(non_snake_case)] +#[derive(Deserialize, Serialize, Clone, Debug)] +pub struct CombinedBindingDocInput { + #[serde(default)] + pub name: Option>>, + #[serde(default)] + pub key: Option>>, + #[serde(default)] + pub description: Option>>, +} + impl Merging for BindingDocInput { fn coalesce(self, new: Self) -> Self { return new; @@ -418,28 +425,34 @@ impl Merging for BindingDocInput { description: self.description.coalesce(y.description), hideInPalette: self.hideInPalette.coalesce(y.hideInPalette), hideInDocs: self.hideInDocs.coalesce(y.hideInDocs), - combinedName: self.combinedName.coalesce(y.combinedName), - combinedKey: self.combinedKey.coalesce(y.combinedKey), - combinedDescription: self.combinedDescription.coalesce(y.combinedDescription), + combined: self.combined.merge(y.combined), kind: self.kind.coalesce(y.kind), } } } +impl Merging for CombinedBindingDocInput { + fn coalesce(self, new: Self) -> Self { + return new; + } + + fn merge(self, y: Self) -> Self { + CombinedBindingDocInput { + name: self.name.coalesce(y.name), + key: self.key.coalesce(y.key), + description: self.description.coalesce(y.description), + } + } +} + impl Expanding for BindingDocInput { fn is_constant(&self) -> bool { - [ - self.name.is_constant(), - self.description.is_constant(), - self.hideInPalette.is_constant(), - self.hideInDocs.is_constant(), - self.combinedName.is_constant(), - self.combinedKey.is_constant(), - self.combinedDescription.is_constant(), - self.kind.is_constant(), - ] - .into_iter() - .all(identity) + return self.name.is_constant() + && self.description.is_constant() + && self.hideInPalette.is_constant() + && self.hideInDocs.is_constant() + && self.combined.is_constant() + && self.kind.is_constant(); } fn map_expressions(self, f: &mut F) -> ResultVec where @@ -467,23 +480,10 @@ impl Expanding for BindingDocInput { errors.append(&mut e.errors); None }), - combinedName: self - .combinedName - .map_expressions(f) - .unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - None - }), - combinedKey: self.combinedKey.map_expressions(f).unwrap_or_else(|mut e| { + combined: self.combined.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); None }), - combinedDescription: self.combinedDescription.map_expressions(f).unwrap_or_else( - |mut e| { - errors.append(&mut e.errors); - None - }, - ), kind: self.kind.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); None @@ -497,6 +497,39 @@ impl Expanding for BindingDocInput { } } +impl Expanding for CombinedBindingDocInput { + fn is_constant(&self) -> bool { + return self.name.is_constant() && self.key.is_constant() && self.description.is_constant(); + } + + fn map_expressions(self, f: &mut F) -> ResultVec + where + Self: Sized, + F: FnMut(Expression) -> Result, + { + let mut errors = Vec::new(); + let result = CombinedBindingDocInput { + name: self.name.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + key: self.key.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + description: self.description.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + None + }), + }; + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } + } +} + impl Resolving for Option { fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { match self { @@ -506,6 +539,19 @@ impl Resolving for Option { } } +impl Resolving> for Option { + fn resolve( + self, + _name: &'static str, + scope: &mut Scope, + ) -> ResultVec> { + return match self { + Some(doc) => Ok(Some(CombinedBindingDoc::new(doc, scope)?)), + Option::None => Ok(None), + }; + } +} + // // ================ `[[bind]]` object ================ // @@ -598,12 +644,19 @@ pub struct BindingDoc { pub description: String, pub hideInPalette: bool, pub hideInDocs: bool, - pub combinedName: String, - pub combinedKey: String, - pub combinedDescription: String, + pub combined: Option, pub kind: String, } +#[derive(Clone, Debug, Serialize, Default)] +#[allow(non_snake_case)] +#[wasm_bindgen(getter_with_clone)] +pub struct CombinedBindingDoc { + name: String, + key: String, + description: String, +} + #[wasm_bindgen] impl BindingDoc { pub(crate) fn new(input: BindingDocInput, scope: &mut Scope) -> ResultVec { @@ -612,14 +665,23 @@ impl BindingDoc { description: resolve!(input, description, scope)?, hideInPalette: resolve!(input, hideInPalette, scope)?, hideInDocs: resolve!(input, hideInDocs, scope)?, - combinedName: resolve!(input, combinedName, scope)?, - combinedKey: resolve!(input, combinedKey, scope)?, - combinedDescription: resolve!(input, combinedDescription, scope)?, + combined: resolve!(input, combined, scope)?, kind: resolve!(input, kind, scope)?, }); } } +#[wasm_bindgen] +impl CombinedBindingDoc { + pub(crate) fn new(input: CombinedBindingDocInput, scope: &mut Scope) -> ResultVec { + return Ok(CombinedBindingDoc { + name: resolve!(input, name, scope)?, + key: resolve!(input, key, scope)?, + description: resolve!(input, description, scope)?, + }); + } +} + // // ================ Tests ================ // @@ -652,9 +714,9 @@ mod tests { doc.description = "foo bar bin" doc.hideInPalette = false doc.hideInDocs = false - doc.combinedName = "Up/down" - doc.combinedKey = "A/B" - doc.combinedDescription = "bla bla bla" + doc.combined.name = "Up/down" + doc.combined.key = "A/B" + doc.combined.description = "bla bla bla" doc.kind = "biz" "#; @@ -718,14 +780,10 @@ mod tests { let hideInPalette: bool = resolve!(doc, hideInPalette, &mut scope).unwrap(); assert_eq!(hideInPalette, false); - let combinedName: String = resolve!(doc, combinedName, &mut scope).unwrap(); - assert_eq!(combinedName, "Up/down"); - - let combinedKey: String = resolve!(doc, combinedKey, &mut scope).unwrap(); - assert_eq!(combinedKey, "A/B"); - - let combinedDescription: String = resolve!(doc, combinedDescription, &mut scope).unwrap(); - assert_eq!(combinedDescription, "bla bla bla"); + let combined: CombinedBindingDoc = resolve!(doc, combined, &mut scope).unwrap().unwrap(); + assert_eq!(combined.name, "Up/down"); + assert_eq!(combined.key, "A/B"); + assert_eq!(combined.description, "bla bla bla"); let kind: String = resolve!(doc, kind, &mut scope).unwrap(); assert_eq!(kind, "biz"); @@ -795,10 +853,8 @@ mod tests { assert_eq!(prefixes, ["b".to_string(), "c".to_string()]); let doc = left.doc.unwrap(); - let description: Option = resolve!(doc, combinedDescription, &mut scope).unwrap(); - assert_eq!(description, None); - let name: Option = resolve!(doc, combinedName, &mut scope).unwrap(); - assert_eq!(name, None); + let combined: Option = resolve!(doc, combined, &mut scope).unwrap(); + assert!(combined.is_none()); } #[test] @@ -986,7 +1042,6 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); let err = Binding::new(input, &mut scope).unwrap_err(); - info!("err: {err}"); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("Undefined mode")); assert_eq!(report[0].range.start.line, 3); From e0dade0352d8c208e4c79b9b0c4fc6d2a52d7001 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 1 Oct 2025 12:03:22 -0400 Subject: [PATCH 59/79] command normalization at runtime Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 2 +- mise.toml | 15 +- notes.md | 43 +- src/presets/larkin.toml | 22 +- src/rust/parsing/coverage/parsing.info | 4515 ++++++++++++++++++++ src/rust/parsing/coverage/parsing.profdata | Bin 548224 -> 1288744 bytes src/rust/parsing/src/bind.rs | 27 +- src/rust/parsing/src/bind/command.rs | 191 +- src/rust/parsing/src/define.rs | 7 +- src/rust/parsing/src/expression.rs | 3 + src/rust/parsing/src/file.rs | 51 +- src/rust/parsing/src/util.rs | 2 +- 12 files changed, 4791 insertions(+), 87 deletions(-) create mode 100644 src/rust/parsing/coverage/parsing.info diff --git a/.vscode/settings.json b/.vscode/settings.json index 773e16e4..e1480020 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,7 +9,7 @@ "src/rust/parsing/Cargo.toml" ], "window.title": "vscode-master-key", - "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.89.0-aarch64-apple-darwin", + "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.90.0-aarch64-apple-darwin", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, diff --git a/mise.toml b/mise.toml index ce486ae8..3b37e6ac 100644 --- a/mise.toml +++ b/mise.toml @@ -7,7 +7,7 @@ node = "20" "npm:pnpm" = "10.13.1" "ubi:haberdashpi/simple-src-docs" = "0.6.0" watchexec = "2.3.2" -rust = { version = "1.89", targets = "wasm32-unknown-unknown", component = "lvm-tools" } +rust = { version = "1.90", targets = "wasm32-unknown-unknown", component = "llvm-tools-preview" } "cargo:wasm-pack" = "0.13.1" "cargo:cargo-binutils" = "0.3.6" "cargo:rustfilt" = "latest" @@ -17,7 +17,8 @@ rust = { version = "1.89", targets = "wasm32-unknown-unknown", component = "lvm- postinstall = [ 'pnpm install --frozen-lockfile', 'pnpm exec playwright install chromium', - 'rustup toolchain install nightly', + 'rustup toolchain install nightly -c llvm-tools-preview', # needed to compute test coverage + 'rustup add target wasm32-unknown-unknown', # mise doesn't seem to install this automatically ] [tasks.lint] @@ -56,12 +57,12 @@ def main [...args] { get filenames.0 | each { |f| $'--object=($in)' } - cargo +nightly test --target wasm32-unknown-unknown --tests ...$args -- --nocapture - cargo profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata - (cargo cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> - ../../../coverage/rs_coverage.info) + cargo +nightly test --tests ...$args -- --nocapture + cargo +nightly profdata -- merge -sparse coverage/parsing.profraw -o coverage/parsing.profdata + (cargo +nightly cov -- export {{vars.coverage_options}} --format=lcov ...($object_files) o> + coverage/parsing.info) - cargo cov -- report --use-color {{vars.coverage_options}} ...($object_files) + cargo +nightly cov -- report --use-color {{vars.coverage_options}} ...($object_files) } else { cargo test ...$args -- --nocapture } diff --git a/notes.md b/notes.md index 7cf4a380..5e61f052 100644 --- a/notes.md +++ b/notes.md @@ -202,44 +202,43 @@ Integration test debugging: - [X] write test cases for error paths - [X] write tests for expressions to specify modes - [X] move `combinedName` and friends to `combined.name` and friends - - [~] command normalization - - [X] always `runCommand` with an array of objects with `command` field - - [ ] flatten all nested `runCommands` calls - - [ ] `skipWhen` will have to be propagated/merged to children + - [X] command normalization + - [X] flatten all nested `runCommands` calls + - [X] flatten all `runCommands` at run-time + - [X] get existing unit tests working + - [X] add unit tests for recurisve `runCommands` called resolved at runtime - [ ] check constraints - [ ] validation that `master-key.prefix` uses `finalKey: false` - - [ ] validation that keybindings with non modifier keybindings - have a condition requiring textEditorFocus - (or just insert it) - - [ ] required keys are present - - [ ] mode expansion: define a key binding per mode - - [ ] key-sequence expansion and duplicate resolution: - - [ ] create a binding per key in a sequence that requires a given prefix - (depending on the prefix code of its prefix) - - [ ] add any missing prefixes + - [ ] no duplicate keybindings: hash each key prefix & mode & when-clause + - [ ] create a map of valid prefixes + - [ ] insert `editorTextFocus` (or palette context) for bare keys + with no prefix - [ ] implement the `all` functions: - [ ] `{{all_prefixes()}}` - [ ] `{{all_prefixes_but()}}` - [X] `{{all_modes()}}` - [X] `{{all_modes_but(["not_me", "or_me"])}}` - - [ ] documentation expandsion/validation across all `[[bind]]` values + - [ ] documentation expansion/validation across all `[[bind]]` values with the same key and mode e.g. merge all shared documentation across the shared names - - [ ] find low hanging fruit for problems with using 1.0 files + - [ ] find low hanging fruit for problems with using 1.0 files / bad fields + - [ ] implement tooling to use different levels (warn/info) + in error reporting - [ ] fields that exist in the old but not new (use `#[serde(flatten)]`) - [ ] add hints for fields that don't exist anywhere as well (probably as a hint or something) - [ ] review strings for single `{}` braces and warn that `{{}}` are now required - - [ ] others - - [ ] implement `[[kind]]` + - [ ] others? + - [ ] implement `[[kind]]` (or redesign) + - [ ] remove spurious line/char positions from expression error messages + - NOTE: these come from the line and char position in the rhai expression + which has nothing to do with the line and char position in the parent + keybinding file - [ ] implement `[header]` section - [ ] instead of using `.mk.toml`, look for a specific heading in the file - - [ ] remove spurious line/char positions from expression error messages - - NOTE: these come from the line and char position in the rhai expression - which has nothing to do with the line and char position in the parent - keybinding file - [ ] proper conversion to keybindings.json command - - [ ] expand prefixes to prefixCode and move to when clause + - [ ] expand per mode and prefix (e.g. each binding has one mode and one prefix) + - [ ] encode prefixes as prefixCode in when clause - [ ] move mode to when clause - [ ] re-implement master-key.do - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 43d5361a..50234952 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -26,7 +26,7 @@ #- NOTE: this file is used to generate both keybindings and to generate a markdown file that documents the bindings. When comments are prefixed with a `-` they are ignored in the final markdown output. All other comments will become part of the markdown output. Any [[bind]] entries unbroken by normal, markdown-displayed comments will show up in a table in the markdown output. Make sure that the normal comments do not break up TOML data in a way that means it is invalid TOML. [header] -doc.name = "Larkin" +name = "Larkin" version = "2.0" requiredExtensions = [ @@ -66,9 +66,7 @@ doc.description = "These commands move the cursor and/or selections." [[kind]] doc.name = "action" doc.description = """ -Actions do something with the selected text (e.g. delete it). Unless otherwise noted, in -the absence of a selection, an action will modify an entire line, and a count argument -indicates the number of lines (e.g. 3d deletes this line and the next 3 lines). +Actions do something with the selected text (e.g. delete it). Unless otherwise noted, in the absence of a selection, an action will modify an entire line, and a count argument indicates the number of lines (e.g. 3d deletes this line and the next 3 lines). """ [[kind]] @@ -181,22 +179,6 @@ args.commands = ["hideSuggestWidget", "master-key.enterNormal"] mode = "{{all_modes()}}" prefixes = "{{all_prefixes()}}" -#- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect -[[bind]] -default = "{{bind.modes}}" -doc.name = "ignore" -doc.description = "this key does nothing" -foreach.key = ["{{keys(`.`}}"] -foreach.modifier = ["shift+", ""] -key = "{{modifier}}{{key}}" -command = "master-key.ignore" -prefixes = "{{all_prefixes()}}" -mode = '{{not_modes(["normal", "selectedit"]}}' -when = "editorTextFocus" -doc.hideInDocs = true -doc.hideInPalette = true -priority = -10 - [[define.bind]] id = "edit" when = "editorTextFocus && !findWidgetVisible" diff --git a/src/rust/parsing/coverage/parsing.info b/src/rust/parsing/coverage/parsing.info new file mode 100644 index 00000000..d7dbd285 --- /dev/null +++ b/src/rust/parsing/coverage/parsing.info @@ -0,0 +1,4515 @@ +SF:src/rust/parsing/src/bind.rs +FN:577,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding6repeat +FN:419,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging8coalesce +FN:435,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging8coalesce +FN:235,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging8coalesce +FN:25,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultINtNtNtB4_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB4_ +FN:25,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultNtNtB2_10validation10KeyBindingEB4_ +FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsBz_E0EB8_ +FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBz_EEE0EB8_ +FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachBz_14expand_foreach00EB8_ +FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1P_6Define6expand0EB8_ +FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ +FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsNtB6_12BindingInputE0EB8_ +FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ +FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1S_6Define6expand0EB8_ +FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ +FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsNtB6_12BindingInputE0EB8_ +FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ +FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB20_6Define6expand0EB8_ +FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0E0Ba_ +FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es0_0Ba_ +FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es1_0Ba_ +FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es2_0Ba_ +FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es3_0Ba_ +FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es4_0Ba_ +FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es5_0Ba_ +FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es6_0Ba_ +FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es7_0Ba_ +FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es8_0Ba_ +FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es9_0Ba_ +FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es_0Ba_ +FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Esa_0Ba_ +FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0E0Ba_ +FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es0_0Ba_ +FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es1_0Ba_ +FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es2_0Ba_ +FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es3_0Ba_ +FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es4_0Ba_ +FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es5_0Ba_ +FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es6_0Ba_ +FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es7_0Ba_ +FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es8_0Ba_ +FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es9_0Ba_ +FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es_0Ba_ +FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Esa_0Ba_ +FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00E0Ba_ +FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es0_0Ba_ +FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es1_0Ba_ +FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es2_0Ba_ +FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es3_0Ba_ +FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es4_0Ba_ +FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es5_0Ba_ +FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es6_0Ba_ +FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es7_0Ba_ +FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es8_0Ba_ +FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es9_0Ba_ +FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es_0Ba_ +FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Esa_0Ba_ +FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0E0Ba_ +FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es0_0Ba_ +FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es1_0Ba_ +FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es2_0Ba_ +FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es3_0Ba_ +FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es4_0Ba_ +FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es5_0Ba_ +FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es6_0Ba_ +FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es7_0Ba_ +FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es8_0Ba_ +FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es9_0Ba_ +FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es_0Ba_ +FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Esa_0Ba_ +FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ +FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ +FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es1_0Ba_ +FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es2_0Ba_ +FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es3_0Ba_ +FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ +FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ +FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ +FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es1_0Ba_ +FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es2_0Ba_ +FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es3_0Ba_ +FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ +FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ +FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ +FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es1_0Ba_ +FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es2_0Ba_ +FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es3_0Ba_ +FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ +FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0E0Ba_ +FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es0_0Ba_ +FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es1_0Ba_ +FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es2_0Ba_ +FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es3_0Ba_ +FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es_0Ba_ +FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ +FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ +FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ +FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ +FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ +FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ +FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ +FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ +FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ +FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0E0Ba_ +FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es0_0Ba_ +FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es_0Ba_ +FN:640,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3new0B9_ +FN:647,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3news_0B9_ +FN:600,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding8commands0B9_ +FN:214,_RNvMNtCslo8MYDYmh8N_7parsing4bindNtB2_12BindingInput10without_id +FN:685,_RNvMs1b_NtCslo8MYDYmh8N_7parsing4bindNtB6_10BindingDoc3new +FN:699,_RNvMs1c_NtCslo8MYDYmh8N_7parsing4bindNtB6_18CombinedBindingDoc3new +FN:604,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding3new +FN:581,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding8commands +FN:29,_RNvNtCslo8MYDYmh8N_7parsing4bind19span_plural_default +FN:259,_RNvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB5_12BindingInputNtNtNtB7_10expression5value9Expanding11is_constant +FN:422,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging5merge +FN:439,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging5merge +FN:449,_RNvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant +FN:501,_RNvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant +FN:238,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging5merge +FN:534,_RNvXs5_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_15BindingDocInputEINtNtB7_4util9ResolvingNtB5_10BindingDocE7resolve +FN:543,_RNvXs6_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_23CombinedBindingDocInputEINtNtB7_4util9ResolvingIBz_NtB5_18CombinedBindingDocEE7resolve +FN:777,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_16complete_parsing0B7_ +FN:1013,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keys0B7_ +FN:1014,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keyss_0B7_ +FNDA:0,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding6repeat +FNDA:0,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging8coalesce +FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging8coalesce +FNDA:0,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging8coalesce +FNDA:6,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultINtNtNtB4_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB4_ +FNDA:11,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultNtNtB2_10validation10KeyBindingEB4_ +FNDA:3,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsBz_E0EB8_ +FNDA:10,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBz_EEE0EB8_ +FNDA:34,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachBz_14expand_foreach00EB8_ +FNDA:13,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1P_6Define6expand0EB8_ +FNDA:4,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ +FNDA:3,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsNtB6_12BindingInputE0EB8_ +FNDA:34,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ +FNDA:5,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1S_6Define6expand0EB8_ +FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ +FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsNtB6_12BindingInputE0EB8_ +FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ +FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB20_6Define6expand0EB8_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0E0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es0_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es1_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es2_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es3_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es4_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es5_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es6_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es7_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es8_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es9_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Esa_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0E0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es0_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es1_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es2_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es3_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es4_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es5_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es6_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es7_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es8_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es9_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Esa_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00E0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es0_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es1_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es2_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es3_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es4_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es5_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es6_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es7_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es8_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es9_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Esa_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0E0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es0_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es1_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es2_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es3_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es4_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es5_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es6_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es7_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es8_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es9_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es_0Ba_ +FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Esa_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es1_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es2_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es3_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es1_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es2_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es3_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es1_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es2_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es3_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0E0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es0_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es1_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es2_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es3_0Ba_ +FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0E0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es0_0Ba_ +FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es_0Ba_ +FNDA:22,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3new0B9_ +FNDA:1,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3news_0B9_ +FNDA:10,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding8commands0B9_ +FNDA:3,_RNvMNtCslo8MYDYmh8N_7parsing4bindNtB2_12BindingInput10without_id +FNDA:13,_RNvMs1b_NtCslo8MYDYmh8N_7parsing4bindNtB6_10BindingDoc3new +FNDA:1,_RNvMs1c_NtCslo8MYDYmh8N_7parsing4bindNtB6_18CombinedBindingDoc3new +FNDA:21,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding3new +FNDA:10,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding8commands +FNDA:58,_RNvNtCslo8MYDYmh8N_7parsing4bind19span_plural_default +FNDA:3,_RNvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB5_12BindingInputNtNtNtB7_10expression5value9Expanding11is_constant +FNDA:2,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging5merge +FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging5merge +FNDA:1,_RNvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant +FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant +FNDA:6,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging5merge +FNDA:19,_RNvXs5_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_15BindingDocInputEINtNtB7_4util9ResolvingNtB5_10BindingDocE7resolve +FNDA:15,_RNvXs6_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_23CombinedBindingDocInputEINtNtB7_4util9ResolvingIBz_NtB5_18CombinedBindingDocEE7resolve +FNDA:3,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_16complete_parsing0B7_ +FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keys0B7_ +FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keyss_0B7_ +FNF:50 +FNH:21 +DA:25,17 +DA:26,17 +DA:27,17 +DA:29,58 +DA:30,58 +DA:31,58 +DA:214,3 +DA:215,3 +DA:216,3 +DA:217,3 +DA:218,3 +DA:219,3 +DA:220,3 +DA:221,3 +DA:222,3 +DA:223,3 +DA:224,3 +DA:225,3 +DA:226,3 +DA:227,3 +DA:228,3 +DA:229,3 +DA:230,3 +DA:231,3 +DA:235,0 +DA:236,0 +DA:237,0 +DA:238,6 +DA:239,6 +DA:240,6 +DA:241,6 +DA:242,6 +DA:243,6 +DA:244,6 +DA:245,6 +DA:246,6 +DA:247,6 +DA:248,6 +DA:249,6 +DA:250,6 +DA:251,6 +DA:252,6 +DA:253,6 +DA:254,6 +DA:255,6 +DA:259,3 +DA:260,3 +DA:261,3 +DA:262,3 +DA:263,3 +DA:264,3 +DA:265,3 +DA:266,3 +DA:267,3 +DA:268,3 +DA:269,3 +DA:270,3 +DA:271,3 +DA:272,3 +DA:273,3 +DA:274,3 +DA:275,3 +DA:276,3 +DA:277,3 +DA:278,60 +DA:279,60 +DA:280,60 +DA:282,60 +DA:283,60 +DA:284,60 +DA:285,60 +DA:286,0 +DA:287,0 +DA:288,0 +DA:289,60 +DA:290,0 +DA:291,0 +DA:292,0 +DA:293,60 +DA:294,0 +DA:295,0 +DA:296,0 +DA:297,60 +DA:298,0 +DA:299,0 +DA:300,0 +DA:301,60 +DA:302,0 +DA:303,0 +DA:304,0 +DA:305,60 +DA:306,0 +DA:307,0 +DA:308,0 +DA:309,60 +DA:310,0 +DA:311,0 +DA:312,0 +DA:313,60 +DA:314,0 +DA:315,0 +DA:316,0 +DA:317,60 +DA:318,0 +DA:319,0 +DA:320,0 +DA:321,60 +DA:322,0 +DA:323,0 +DA:324,0 +DA:325,60 +DA:326,0 +DA:327,0 +DA:328,0 +DA:329,60 +DA:330,0 +DA:331,0 +DA:332,0 +DA:333,60 +DA:334,0 +DA:335,0 +DA:336,0 +DA:338,60 +DA:339,0 +DA:341,60 +DA:343,60 +DA:419,0 +DA:420,0 +DA:421,0 +DA:422,2 +DA:423,2 +DA:424,2 +DA:425,2 +DA:426,2 +DA:427,2 +DA:428,2 +DA:429,2 +DA:430,2 +DA:431,2 +DA:435,0 +DA:436,0 +DA:437,0 +DA:439,0 +DA:440,0 +DA:441,0 +DA:442,0 +DA:443,0 +DA:444,0 +DA:445,0 +DA:449,1 +DA:450,1 +DA:451,1 +DA:452,1 +DA:453,1 +DA:454,1 +DA:455,1 +DA:456,1 +DA:457,46 +DA:458,46 +DA:459,46 +DA:460,46 +DA:462,46 +DA:463,46 +DA:464,46 +DA:465,0 +DA:466,0 +DA:467,0 +DA:468,46 +DA:469,0 +DA:470,0 +DA:471,0 +DA:472,46 +DA:473,46 +DA:474,46 +DA:475,46 +DA:476,0 +DA:477,0 +DA:478,0 +DA:479,46 +DA:480,0 +DA:481,0 +DA:482,0 +DA:483,46 +DA:484,0 +DA:485,0 +DA:486,0 +DA:487,46 +DA:488,0 +DA:489,0 +DA:490,0 +DA:492,46 +DA:493,0 +DA:495,46 +DA:497,46 +DA:501,0 +DA:502,0 +DA:503,0 +DA:505,0 +DA:506,0 +DA:507,0 +DA:508,0 +DA:510,0 +DA:511,0 +DA:512,0 +DA:513,0 +DA:514,0 +DA:515,0 +DA:516,0 +DA:517,0 +DA:518,0 +DA:519,0 +DA:520,0 +DA:521,0 +DA:522,0 +DA:523,0 +DA:525,0 +DA:526,0 +DA:528,0 +DA:530,0 +DA:534,19 +DA:535,19 +DA:536,13 +DA:537,6 +DA:539,19 +DA:543,15 +DA:544,15 +DA:545,15 +DA:546,15 +DA:547,15 +DA:548,15 +DA:549,1 +DA:550,14 +DA:552,15 +DA:577,0 +DA:578,0 +DA:579,0 +DA:581,10 +DA:582,10 +DA:583,10 +DA:584,10 +DA:585,10 +DA:587,0 +DA:590,10 +DA:592,10 +DA:593,20 +DA:594,10 +DA:595,10 +DA:598,10 +DA:599,10 +DA:600,10 +DA:601,10 +DA:602,10 +DA:604,21 +DA:605,21 +DA:606,0 +DA:607,21 +DA:609,21 +DA:610,0 +DA:611,21 +DA:612,21 +DA:616,21 +DA:617,5 +DA:618,16 +DA:621,19 +DA:622,21 +DA:623,21 +DA:624,20 +DA:625,20 +DA:626,15 +DA:627,5 +DA:629,19 +DA:630,19 +DA:631,19 +DA:632,19 +DA:633,19 +DA:634,19 +DA:637,19 +DA:638,19 +DA:639,19 +DA:640,22 +DA:641,19 +DA:642,19 +DA:643,1 +DA:644,1 +DA:645,1 +DA:646,1 +DA:647,1 +DA:648,1 +DA:649,1 +DA:651,1 +DA:652,18 +DA:654,18 +DA:655,21 +DA:685,13 +DA:687,13 +DA:688,13 +DA:689,13 +DA:690,13 +DA:691,13 +DA:692,13 +DA:694,13 +DA:699,1 +DA:701,1 +DA:702,1 +DA:703,1 +DA:705,1 +DA:777,3 +DA:1013,9 +DA:1014,9 +BRF:0 +BRH:0 +LF:334 +LH:206 +end_of_record +SF:src/rust/parsing/src/bind/command.rs +FN:304,_RNvMs4_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command3new +FN:97,_RNvMs_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB4_12CommandInput10without_id +FN:136,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike4args +FN:133,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike7command +FN:158,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike4args +FN:155,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike7command +FN:320,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputINtNtB9_4util9ResolvingNtB5_7CommandE7resolve +FN:326,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtNtNtB9_10expression5value9Expanding11is_constant +FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_12CommandValueEB6_ +FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_7CommandEB6_ +FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12BindingInputEB6_ +FN:330,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B10_NtB10_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EE0EBa_ +FN:330,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EBW_16require_constant0EBa_ +FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueE0B8_ +FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs0_0B8_ +FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs_0B8_ +FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandE0B8_ +FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs0_0B8_ +FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs_0B8_ +FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputE0B8_ +FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs0_0B8_ +FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs_0B8_ +FN:338,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0E0Bc_ +FN:342,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0Es_0Bc_ +FN:338,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0E0Bc_ +FN:342,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0Es_0Bc_ +FN:68,_RINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB3_12CommandInputNtNtNtB7_10expression5value9Expanding15map_expressionspEB7_ +FN:75,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspE0B9_ +FN:83,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs0_0B9_ +FN:79,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs_0B9_ +FN:293,_RNvMsu_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command4args +FN:59,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB2_12CommandInputNtNtNtB6_10expression5value9Expanding11is_constant +FN:466,_RNCNvNtNtNtCslo8MYDYmh8N_7parsing4bind7command5testss_22command_gets_flattened0B9_ +FN:149,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike4args +FN:145,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike7command +FN:108,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtNtNtB9_10expression5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_12CommandInputE4from +FNDA:0,_RNvMs4_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command3new +FNDA:2,_RNvMs_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB4_12CommandInput10without_id +FNDA:1,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike4args +FNDA:1,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike7command +FNDA:10,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike4args +FNDA:10,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike7command +FNDA:0,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputINtNtB9_4util9ResolvingNtB5_7CommandE7resolve +FNDA:10,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtNtNtB9_10expression5value9Expanding11is_constant +FNDA:1,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_12CommandValueEB6_ +FNDA:10,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_7CommandEB6_ +FNDA:24,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12BindingInputEB6_ +FNDA:10,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B10_NtB10_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EE0EBa_ +FNDA:10,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EBW_16require_constant0EBa_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueE0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs0_0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs_0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandE0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs0_0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs_0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputE0B8_ +FNDA:1,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs0_0B8_ +FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs_0B8_ +FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0E0Bc_ +FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0Es_0Bc_ +FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0E0Bc_ +FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0Es_0Bc_ +FNDA:0,_RINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB3_12CommandInputNtNtNtB7_10expression5value9Expanding15map_expressionspEB7_ +FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspE0B9_ +FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs0_0B9_ +FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs_0B9_ +FNDA:0,_RNvMsu_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command4args +FNDA:0,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB2_12CommandInputNtNtNtB6_10expression5value9Expanding11is_constant +FNDA:4,_RNCNvNtNtNtCslo8MYDYmh8N_7parsing4bind7command5testss_22command_gets_flattened0B9_ +FNDA:24,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike4args +FNDA:24,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike7command +FNDA:2,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtNtNtB9_10expression5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_12CommandInputE4from +FNF:25 +FNH:13 +DA:59,0 +DA:60,0 +DA:61,0 +DA:62,0 +DA:63,0 +DA:64,0 +DA:65,0 +DA:66,0 +DA:67,0 +DA:68,0 +DA:69,0 +DA:70,0 +DA:72,0 +DA:73,0 +DA:74,0 +DA:75,0 +DA:76,0 +DA:77,0 +DA:78,0 +DA:79,0 +DA:80,0 +DA:81,0 +DA:82,0 +DA:83,0 +DA:84,0 +DA:85,0 +DA:86,0 +DA:88,0 +DA:89,0 +DA:91,0 +DA:93,0 +DA:97,2 +DA:98,2 +DA:99,2 +DA:100,2 +DA:101,2 +DA:102,2 +DA:103,2 +DA:104,2 +DA:108,2 +DA:109,2 +DA:110,2 +DA:111,2 +DA:112,2 +DA:113,2 +DA:114,2 +DA:115,2 +DA:116,2 +DA:117,2 +DA:118,2 +DA:133,1 +DA:134,1 +DA:135,1 +DA:136,1 +DA:137,1 +DA:138,1 +DA:139,0 +DA:141,1 +DA:145,24 +DA:146,24 +DA:147,24 +DA:149,24 +DA:150,24 +DA:151,24 +DA:155,10 +DA:156,10 +DA:157,10 +DA:158,10 +DA:159,10 +DA:160,10 +DA:163,35 +DA:164,35 +DA:165,35 +DA:166,35 +DA:167,35 +DA:168,35 +DA:169,29 +DA:170,29 +DA:171,29 +DA:172,6 +DA:173,23 +DA:175,29 +DA:177,29 +DA:179,6 +DA:180,6 +DA:181,6 +DA:182,6 +DA:183,6 +DA:184,6 +DA:185,6 +DA:186,6 +DA:187,6 +DA:188,6 +DA:189,6 +DA:191,0 +DA:194,6 +DA:195,6 +DA:197,0 +DA:198,0 +DA:202,6 +DA:204,19 +DA:206,14 +DA:207,4 +DA:208,4 +DA:209,4 +DA:210,4 +DA:211,4 +DA:212,10 +DA:213,10 +DA:214,1 +DA:215,1 +DA:216,9 +DA:217,9 +DA:219,0 +DA:220,0 +DA:225,9 +DA:226,1 +DA:229,0 +DA:230,0 +DA:231,0 +DA:232,0 +DA:233,1 +DA:234,1 +DA:235,1 +DA:236,1 +DA:237,1 +DA:238,1 +DA:239,1 +DA:240,1 +DA:241,0 +DA:242,1 +DA:243,1 +DA:245,8 +DA:246,4 +DA:247,4 +DA:249,8 +DA:250,7 +DA:251,1 +DA:253,0 +DA:257,8 +DA:258,7 +DA:259,1 +DA:261,8 +DA:262,8 +DA:266,0 +DA:267,0 +DA:268,0 +DA:271,12 +DA:272,12 +DA:273,12 +DA:274,12 +DA:275,12 +DA:278,5 +DA:280,35 +DA:293,0 +DA:294,0 +DA:295,0 +DA:296,0 +DA:297,0 +DA:298,0 +DA:300,0 +DA:304,0 +DA:305,0 +DA:306,0 +DA:307,0 +DA:309,0 +DA:310,0 +DA:311,0 +DA:312,0 +DA:314,0 +DA:316,0 +DA:320,0 +DA:321,0 +DA:322,0 +DA:326,10 +DA:327,10 +DA:328,10 +DA:330,20 +DA:331,20 +DA:332,20 +DA:333,20 +DA:335,20 +DA:336,20 +DA:337,20 +DA:338,20 +DA:339,0 +DA:340,0 +DA:341,0 +DA:342,20 +DA:343,0 +DA:344,0 +DA:345,0 +DA:348,20 +DA:349,0 +DA:351,20 +DA:353,20 +DA:466,4 +BRF:0 +BRH:0 +LF:206 +LH:126 +end_of_record +SF:src/rust/parsing/src/bind/foreach.rs +FN:269,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys +FN:251,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys +FN:326,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values +FN:293,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput11has_foreach +FN:300,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput14expand_foreach +FN:310,_RNCNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB8_12BindingInput14expand_foreach00Ba_ +FN:282,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys00B9_ +FN:333,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values00B9_ +FN:307,_RNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB6_12BindingInput14expand_foreach0B8_ +FN:279,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys0B7_ +FN:262,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys0B7_ +FN:332,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values0B7_ +FNDA:4,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys +FNDA:3,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys +FNDA:4,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values +FNDA:12,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput11has_foreach +FNDA:12,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput14expand_foreach +FNDA:86,_RNCNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB8_12BindingInput14expand_foreach00Ba_ +FNDA:7,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys00B9_ +FNDA:36,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values00B9_ +FNDA:34,_RNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB6_12BindingInput14expand_foreach0B8_ +FNDA:5,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys0B7_ +FNDA:216,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys0B7_ +FNDA:6,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values0B7_ +FNF:12 +FNH:12 +DA:251,3 +DA:252,3 +DA:253,3 +DA:254,3 +DA:255,0 +DA:256,0 +DA:258,3 +DA:260,3 +DA:261,579 +DA:262,576 +DA:263,30 +DA:264,546 +DA:266,3 +DA:267,3 +DA:269,4 +DA:270,4 +DA:271,4 +DA:272,4 +DA:274,4 +DA:277,4 +DA:278,4 +DA:279,5 +DA:280,5 +DA:281,5 +DA:282,7 +DA:283,3 +DA:284,4 +DA:285,7 +DA:286,5 +DA:287,5 +DA:288,5 +DA:289,4 +DA:290,4 +DA:293,12 +DA:294,12 +DA:295,4 +DA:296,8 +DA:297,8 +DA:298,12 +DA:300,12 +DA:301,12 +DA:302,4 +DA:303,4 +DA:305,0 +DA:307,34 +DA:308,34 +DA:309,34 +DA:310,86 +DA:311,86 +DA:312,0 +DA:313,86 +DA:314,102 +DA:315,102 +DA:316,102 +DA:317,86 +DA:318,86 +DA:319,34 +DA:320,4 +DA:321,8 +DA:322,8 +DA:323,12 +DA:326,4 +DA:327,4 +DA:329,9 +DA:330,5 +DA:331,5 +DA:332,6 +DA:333,36 +DA:334,36 +DA:335,36 +DA:336,36 +DA:337,36 +DA:338,6 +DA:339,5 +DA:342,4 +DA:343,4 +BRF:0 +BRH:0 +LF:83 +LH:79 +end_of_record +SF:src/rust/parsing/src/bind/validation.rs +FN:194,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging5merge +FN:197,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging8coalesce +FN:267,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_16BindingReferenceE4from +FN:277,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging5merge +FN:273,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging8coalesce +FN:185,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_10KeyBindingE4from +FN:203,_RNvMs3_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBinding6unwrap +FN:102,_RNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str +FN:127,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind10validationNtB2_10KeyBindingINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from +FN:148,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtNtB9_10expression5value9Expanding11is_constant +FN:228,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from +FN:254,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtNtB9_10expression5value9Expanding11is_constant +FN:140,_RNvXs_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB4_10KeyBindingINtNtB8_4util9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolve +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsNtB8_12BindingInputE0EBa_ +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope6expandBN_E0EBa_ +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB21_6Define6expand0EBa_ +FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYBN_B14_16require_constant0EBa_ +FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ +FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsNtB8_12BindingInputE0EBa_ +FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ +FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB27_6Define6expand0EBa_ +FN:108,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str0B7_ +FNDA:0,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging5merge +FNDA:0,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging8coalesce +FNDA:0,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_16BindingReferenceE4from +FNDA:0,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging5merge +FNDA:0,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging8coalesce +FNDA:23,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_10KeyBindingE4from +FNDA:1,_RNvMs3_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBinding6unwrap +FNDA:29,_RNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str +FNDA:20,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind10validationNtB2_10KeyBindingINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from +FNDA:1,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtNtB9_10expression5value9Expanding11is_constant +FNDA:4,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from +FNDA:1,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtNtB9_10expression5value9Expanding11is_constant +FNDA:21,_RNvXs_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB4_10KeyBindingINtNtB8_4util9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolve +FNDA:9,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ +FNDA:1,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsNtB8_12BindingInputE0EBa_ +FNDA:21,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope6expandBN_E0EBa_ +FNDA:10,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ +FNDA:10,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB21_6Define6expand0EBa_ +FNDA:21,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYBN_B14_16require_constant0EBa_ +FNDA:2,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ +FNDA:0,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsNtB8_12BindingInputE0EBa_ +FNDA:0,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ +FNDA:3,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB27_6Define6expand0EBa_ +FNDA:127,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str0B7_ +FNF:16 +FNH:11 +DA:102,29 +DA:103,39 +DA:104,39 +DA:105,39 +DA:106,39 +DA:107,39 +DA:108,127 +DA:109,0 +DA:110,39 +DA:112,0 +DA:113,0 +DA:114,0 +DA:118,29 +DA:119,29 +DA:127,20 +DA:128,20 +DA:130,1 +DA:133,19 +DA:134,19 +DA:136,20 +DA:140,21 +DA:141,21 +DA:142,21 +DA:143,21 +DA:144,21 +DA:148,1 +DA:149,1 +DA:150,1 +DA:151,0 +DA:153,1 +DA:154,72 +DA:155,72 +DA:156,72 +DA:158,72 +DA:159,50 +DA:160,22 +DA:161,12 +DA:162,0 +DA:163,10 +DA:164,10 +DA:165,10 +DA:167,0 +DA:168,0 +DA:169,0 +DA:170,0 +DA:171,0 +DA:172,0 +DA:173,0 +DA:174,0 +DA:175,0 +DA:177,0 +DA:181,72 +DA:185,23 +DA:186,23 +DA:187,23 +DA:188,0 +DA:190,23 +DA:194,0 +DA:195,0 +DA:196,0 +DA:197,0 +DA:198,0 +DA:199,0 +DA:203,1 +DA:204,1 +DA:205,1 +DA:206,0 +DA:208,1 +DA:228,4 +DA:229,4 +DA:230,4 +DA:231,4 +DA:232,4 +DA:233,4 +DA:234,4 +DA:235,4 +DA:237,0 +DA:238,0 +DA:239,0 +DA:242,0 +DA:243,0 +DA:244,0 +DA:246,4 +DA:254,1 +DA:255,1 +DA:256,1 +DA:257,5 +DA:258,5 +DA:259,5 +DA:260,5 +DA:262,5 +DA:263,5 +DA:267,0 +DA:268,0 +DA:269,0 +DA:273,0 +DA:274,0 +DA:275,0 +DA:277,0 +DA:278,0 +DA:279,0 +BRF:0 +BRH:0 +LF:102 +LH:62 +end_of_record +SF:src/rust/parsing/src/define.rs +FN:258,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define12add_to_scope +FN:188,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define3new +FN:268,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define6expand +FN:297,_RNCNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB6_6Define6expand00B8_ +FN:210,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3new0B6_ +FN:228,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3news_0B6_ +FN:290,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define6expand0B6_ +FN:318,_RNvNtNtCslo8MYDYmh8N_7parsing6define5testss_14simple_parsing +FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define12add_to_scope +FNDA:14,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define3new +FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define6expand +FNDA:0,_RNCNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB6_6Define6expand00B8_ +FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3new0B6_ +FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3news_0B6_ +FNDA:16,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define6expand0B6_ +FNDA:1,_RNvNtNtCslo8MYDYmh8N_7parsing6define5testss_14simple_parsing +FNF:8 +FNH:5 +DA:188,14 +DA:189,14 +DA:190,14 +DA:191,14 +DA:192,14 +DA:194,14 +DA:195,5 +DA:196,5 +DA:197,5 +DA:198,5 +DA:199,5 +DA:200,0 +DA:201,0 +DA:202,0 +DA:207,14 +DA:208,3 +DA:209,3 +DA:210,3 +DA:211,3 +DA:212,3 +DA:213,0 +DA:214,3 +DA:215,0 +DA:216,0 +DA:217,0 +DA:218,3 +DA:219,3 +DA:220,3 +DA:225,14 +DA:226,4 +DA:227,4 +DA:228,4 +DA:229,4 +DA:230,4 +DA:231,0 +DA:232,4 +DA:233,0 +DA:234,0 +DA:235,0 +DA:236,4 +DA:237,4 +DA:238,4 +DA:243,14 +DA:244,0 +DA:250,14 +DA:251,14 +DA:252,14 +DA:253,14 +DA:254,14 +DA:256,14 +DA:258,13 +DA:259,13 +DA:260,3 +DA:261,3 +DA:263,3 +DA:265,13 +DA:266,13 +DA:268,13 +DA:270,13 +DA:271,3 +DA:272,3 +DA:273,3 +DA:274,0 +DA:275,3 +DA:278,3 +DA:279,3 +DA:280,3 +DA:281,3 +DA:283,0 +DA:285,3 +DA:287,10 +DA:290,16 +DA:291,16 +DA:292,16 +DA:293,2 +DA:294,2 +DA:295,2 +DA:296,2 +DA:297,2 +DA:298,2 +DA:299,2 +DA:300,14 +DA:301,14 +DA:302,0 +DA:303,0 +DA:304,0 +DA:305,14 +DA:306,14 +DA:307,16 +DA:308,13 +DA:318,1 +DA:319,1 +DA:320,1 +DA:321,1 +DA:322,1 +DA:323,1 +DA:324,1 +DA:325,1 +DA:326,1 +DA:327,1 +DA:328,1 +DA:329,1 +DA:330,1 +DA:331,1 +DA:332,1 +DA:333,1 +DA:334,1 +DA:335,1 +DA:336,1 +DA:337,1 +DA:339,1 +DA:340,1 +DA:342,1 +DA:343,1 +DA:344,1 +DA:345,1 +DA:346,1 +DA:347,1 +DA:349,1 +DA:350,1 +DA:351,1 +DA:352,1 +DA:355,1 +DA:356,1 +DA:357,1 +DA:358,1 +DA:359,1 +DA:361,1 +DA:362,1 +DA:363,1 +DA:364,1 +DA:365,1 +DA:366,1 +DA:367,1 +DA:369,1 +BRF:0 +BRH:0 +LF:139 +LH:119 +end_of_record +SF:src/rust/parsing/src/error.rs +FN:78,_RNCNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB7_9Spannable5range0B9_ +FN:379,_RNvMs1F_NtCslo8MYDYmh8N_7parsing5errorNtB6_11ErrorReport3new +FN:71,_RNvXININtCslo8MYDYmh8N_7parsing5error0pEINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpENtB5_9Spannable5rangeB7_ +FN:77,_RNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB5_9Spannable5rangeB7_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB26_7flatten7FlattenINtNtB2a_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBM_EEENCNvMNtB4_4fileNtB4l_7KeyFile3news_0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB2U_3VecBM_ENtB3Q_9Expanding15map_expressionsNCINvMsf_B3S_NtB3S_5Scope10parse_astsB4f_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsIB42_IBN_NtNtB4_4bind12BindingInputEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB33_6string6StringB41_EE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4W_12BindingInput14expand_foreach00E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4S_6Define6expand0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB4_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB27_6string6StringNtNtNtB4_10expression5value5ValueEENCNvMNtBO_7foreachBM_14expand_foreach0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterBM_ENCNvXsq_NtB4_4utilINtB2V_6PluralBM_EINtB2V_9ResolvingINtB2h_3VecBM_EE7resolve0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsB2J_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsINtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandB2J_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueBM_EE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuebEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuedEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2h_3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2J_EEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4e_12BindingInput14expand_foreach00E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4a_6Define6expand0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYB2J_B3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueBM_EB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuebEB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuedEB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2h_3VecNtNtNtB4_4bind7command7CommandEB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecB2J_EEB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3y_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsBM_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandBM_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandIB3c_NtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueNtNtB2e_6string6StringEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuebEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuedEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBM_EEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB45_12BindingInput14expand_foreach00E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvMNtB4_6defineNtB41_6Define6expand0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYBM_B3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYIB3c_NtNtNtB4_4bind7command7CommandEB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueNtNtB2e_6string6StringEB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuebEB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuedEB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringB3b_EB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3q_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCINvMsf_B37_NtB37_5Scope6expandB3u_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCNvYB3u_B3J_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBO_12CommandInputENCNvXsq_NtB4_4utilINtB3k_6PluralB2S_EINtB3k_9ResolvingINtB29_3VecBM_EE7resolve0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsIB1q_IB1G_NtNtB4_4bind12BindingInputEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope6expandB4Y_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB62_12BindingInput14expand_foreach00E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNvMNtB4_6defineNtB5Y_6Define6expand0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecNtNtNtB4_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B1H_INtB37_8IndexMapBN_B1p_ENtB1H_9Expanding15map_expressionsNCNvYB49_B4x_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsB1p_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandB1p_E0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueBN_EE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuebEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuedEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1p_EEEE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB55_12BindingInput14expand_foreach00E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvMNtB4_6defineNtB51_6Define6expand0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYB1p_B4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueBN_EB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuebEB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuedEB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecB1p_EEB4p_16require_constant0E0EEB4_ +FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB4p_16require_constant0E0EEB4_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs_0B6_ +FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EE0B6_ +FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs0_0B6_ +FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs_0B6_ +FN:298,_RNCNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB8_5Error6report0Ba_ +FN:349,_RNCNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB8_8ErrorSet6report0Ba_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1i_6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB9_4bind7BindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuebENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuedENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuelENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4bind12BindingInputNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode13WhenNoBindingNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode4ModeNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_10expression5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_4bind10validation16BindingReferenceNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB7_8ErrorSetEINtB7_12ErrorContextbE12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB7_8ErrorSetEINtB7_12ErrorContextdE12with_context0B9_ +FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB7_8ErrorSetEINtB7_12ErrorContextuE12with_context0B9_ +FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ +FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtBP_3num5error15TryFromIntErrorE4fromB7_ +FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ +FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ +FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ +FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml3ser5error5ErrorE4fromB7_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtB1m_5error8ErrorSetENtB26_8RawErrorEINtB26_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1m_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4bind7BindingNtNtBN_5error8ErrorSetENtB1o_8RawErrorEINtB1o_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4mode5ModesNtNtBN_5error8ErrorSetENtB1m_8RawErrorEINtB1m_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtB1A_5error8RawErrorEINtB36_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1A_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtB28_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB2a_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtBK_6string6StringENtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1A_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1C_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtCslo8MYDYmh8N_7parsing4bind7BindingENtNtB1g_5error8ErrorSetEINtB1S_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1g_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredINtNtNtBK_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBK_5error8ErrorSetEINtB2E_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredNtNtNtBK_4bind10validation10KeyBindingENtNtBK_5error8ErrorSetEINtB1Z_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBM_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBM_5error8ErrorSetEINtB2C_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtNtBM_5error8ErrorSetEINtB2h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuelENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1g_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1i_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1j_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1l_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4bind12BindingInputNtNtBJ_5error8ErrorSetEINtB1q_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode13WhenNoBindingNtNtBJ_5error8ErrorSetEINtB1r_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode4ModeNtNtBJ_5error8ErrorSetEINtB1h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtBL_5types11parse_error10ParseErrorEINtNtCslo8MYDYmh8N_7parsing5error12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB20_ +FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error5ErrorEINtB1x_12ErrorContextBF_E12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBL_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error8ErrorSetEINtB1x_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing4bind10validation16BindingReferenceNtNtBL_5error8ErrorSetEINtB1I_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultbNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextbE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultdNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextdE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBK_ +FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageReEBK_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextuE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultzNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextzE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FN:111,_RNvXs1_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_5ErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB7_4bind7command7CommandENtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4bind7BindingNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4mode5ModesNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtB1h_5types11parse_error10ParseErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8RawErrorEINtB5_12ErrorContextuE12with_contextB7_ +FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultzNtB5_8RawErrorEINtB5_12ErrorContextzE12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1g_6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB7_4bind7BindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueINtNtB7_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuebENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuedENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuelENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4bind12BindingInputNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode13WhenNoBindingNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode4ModeNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_4bind10validation16BindingReferenceNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB5_8ErrorSetEINtB5_12ErrorContextbE12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB5_8ErrorSetEINtB5_12ErrorContextdE12with_contextB7_ +FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8ErrorSetEINtB5_12ErrorContextuE12with_contextB7_ +FN:83,_RNvXs0_NtCslo8MYDYmh8N_7parsing5errorINtNtNtCs7micvSKFzzu_4core3ops5range5RangejENtB5_9Spannable5range +FN:289,_RNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB6_5Error6report +FN:348,_RNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB6_8ErrorSet6report +FN:253,_RNvNtCslo8MYDYmh8N_7parsing5error12range_to_pos +FN:266,_RNvNtCslo8MYDYmh8N_7parsing5error38resolve_rhai_pos_from_expression_range +FN:46,_RNvNtCslo8MYDYmh8N_7parsing5error3err +FN:137,_RNvXs3_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc5boxed3BoxNtNtNtCsdKkeGZLW2Fi_4rhai5types5error13EvalAltResultEE4from +FN:159,_RNvXs4_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ErrorE4from +FN:193,_RNvXs6_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ErrorEE4from +FN:237,_RNvXs9_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorNtNtCs7micvSKFzzu_4core3fmt7Display3fmt +FN:361,_RNvXsa_NtCslo8MYDYmh8N_7parsing5errorNtB5_9CharRangeNtNtCs7micvSKFzzu_4core7default7Default7default +FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB7_9Spannable5range0B9_ +FNDA:0,_RNvMs1F_NtCslo8MYDYmh8N_7parsing5errorNtB6_11ErrorReport3new +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing5error0pEINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpENtB5_9Spannable5rangeB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB5_9Spannable5rangeB7_ +FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB26_7flatten7FlattenINtNtB2a_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBM_EEENCNvMNtB4_4fileNtB4l_7KeyFile3news_0EEB4_ +FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB2U_3VecBM_ENtB3Q_9Expanding15map_expressionsNCINvMsf_B3S_NtB3S_5Scope10parse_astsB4f_E0E0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsIB42_IBN_NtNtB4_4bind12BindingInputEEE0E0EEB4_ +FNDA:3,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB33_6string6StringB41_EE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4W_12BindingInput14expand_foreach00E0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4S_6Define6expand0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB4_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB27_6string6StringNtNtNtB4_10expression5value5ValueEENCNvMNtBO_7foreachBM_14expand_foreach0EEB4_ +FNDA:46,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterBM_ENCNvXsq_NtB4_4utilINtB2V_6PluralBM_EINtB2V_9ResolvingINtB2h_3VecBM_EE7resolve0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsB2J_E0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsINtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandB2J_E0E0EEB4_ +FNDA:27,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueBM_EE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuebEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuedEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2h_3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2J_EEEE0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4e_12BindingInput14expand_foreach00E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4a_6Define6expand0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYB2J_B3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueBM_EB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuebEB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuedEB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2h_3VecNtNtNtB4_4bind7command7CommandEB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecB2J_EEB3y_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3y_16require_constant0E0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsBM_E0E0EEB4_ +FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandBM_E0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandIB3c_NtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEE0E0EEB4_ +FNDA:27,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueNtNtB2e_6string6StringEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuebEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuedEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBM_EEEE0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FNDA:52,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB45_12BindingInput14expand_foreach00E0EEB4_ +FNDA:8,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvMNtB4_6defineNtB41_6Define6expand0E0EEB4_ +FNDA:8,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYBM_B3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYIB3c_NtNtNtB4_4bind7command7CommandEB3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEB3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueNtNtB2e_6string6StringEB3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuebEB3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuedEB3q_16require_constant0E0EEB4_ +FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringB3b_EB3q_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3q_16require_constant0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCINvMsf_B37_NtB37_5Scope6expandB3u_E0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCNvYB3u_B3J_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBO_12CommandInputENCNvXsq_NtB4_4utilINtB3k_6PluralB2S_EINtB3k_9ResolvingINtB29_3VecBM_EE7resolve0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsIB1q_IB1G_NtNtB4_4bind12BindingInputEEE0E0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope6expandB4Y_E0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB62_12BindingInput14expand_foreach00E0EEB4_ +FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNvMNtB4_6defineNtB5Y_6Define6expand0E0EEB4_ +FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecNtNtNtB4_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B1H_INtB37_8IndexMapBN_B1p_ENtB1H_9Expanding15map_expressionsNCNvYB49_B4x_16require_constant0E0EEB4_ +FNDA:6,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsB1p_E0E0EEB4_ +FNDA:9,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ +FNDA:3,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ +FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandB1p_E0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueBN_EE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuebEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuedEE0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1p_EEEE0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ +FNDA:34,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB55_12BindingInput14expand_foreach00E0EEB4_ +FNDA:14,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvMNtB4_6defineNtB51_6Define6expand0E0EEB4_ +FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYB1p_B4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueBN_EB4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEB4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuebEB4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuedEB4p_16require_constant0E0EEB4_ +FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEB4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecB1p_EEB4p_16require_constant0E0EEB4_ +FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB4p_16require_constant0E0EEB4_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs_0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs_0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FNDA:7,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EE0B6_ +FNDA:7,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs_0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EE0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs_0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EE0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs_0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EE0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EE0B6_ +FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs_0B6_ +FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EE0B6_ +FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs_0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs_0B6_ +FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs0_0B6_ +FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs_0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EE0B6_ +FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs_0B6_ +FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EE0B6_ +FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs_0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FNDA:112,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EE0B6_ +FNDA:112,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs_0B6_ +FNDA:16,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EE0B6_ +FNDA:16,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs_0B6_ +FNDA:17,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EE0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs0_0B6_ +FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs_0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EE0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs_0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs_0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EE0B6_ +FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs_0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EE0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs_0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EE0B6_ +FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs_0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EE0B6_ +FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs_0B6_ +FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs0_0B6_ +FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs_0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ +FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ +FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EE0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs_0B6_ +FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ +FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EE0B6_ +FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs_0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EE0B6_ +FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs_0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EE0B6_ +FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs_0B6_ +FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EE0B6_ +FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EE0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs0_0B6_ +FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs_0B6_ +FNDA:0,_RNCNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB8_5Error6report0Ba_ +FNDA:14,_RNCNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB8_8ErrorSet6report0Ba_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1i_6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:2,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB9_4bind7BindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuebENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuedENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuelENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4bind12BindingInputNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode13WhenNoBindingNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode4ModeNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_10expression5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_4bind10validation16BindingReferenceNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB7_8ErrorSetEINtB7_12ErrorContextbE12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB7_8ErrorSetEINtB7_12ErrorContextdE12with_context0B9_ +FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB7_8ErrorSetEINtB7_12ErrorContextuE12with_context0B9_ +FNDA:18,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ +FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtBP_3num5error15TryFromIntErrorE4fromB7_ +FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ +FNDA:2,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ +FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ +FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml3ser5error5ErrorE4fromB7_ +FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtB1m_5error8ErrorSetENtB26_8RawErrorEINtB26_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1m_ +FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4bind7BindingNtNtBN_5error8ErrorSetENtB1o_8RawErrorEINtB1o_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ +FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4mode5ModesNtNtBN_5error8ErrorSetENtB1m_8RawErrorEINtB1m_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ +FNDA:3,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtB1A_5error8RawErrorEINtB36_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1A_ +FNDA:4,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtB28_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB2a_ +FNDA:47,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtBK_6string6StringENtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1A_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1C_ +FNDA:10,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtCslo8MYDYmh8N_7parsing4bind7BindingENtNtB1g_5error8ErrorSetEINtB1S_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1g_ +FNDA:60,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredINtNtNtBK_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBK_5error8ErrorSetEINtB2E_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:60,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredNtNtNtBK_4bind10validation10KeyBindingENtNtBK_5error8ErrorSetEINtB1Z_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:128,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBM_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBM_5error8ErrorSetEINtB2C_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FNDA:46,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtNtBM_5error8ErrorSetEINtB2h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuelENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ +FNDA:13,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1g_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1i_ +FNDA:90,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1j_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1l_ +FNDA:10,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4bind12BindingInputNtNtBJ_5error8ErrorSetEINtB1q_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FNDA:6,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode13WhenNoBindingNtNtBJ_5error8ErrorSetEINtB1r_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FNDA:16,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode4ModeNtNtBJ_5error8ErrorSetEINtB1h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ +FNDA:25,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtBL_5types11parse_error10ParseErrorEINtNtCslo8MYDYmh8N_7parsing5error12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB20_ +FNDA:71,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error5ErrorEINtB1x_12ErrorContextBF_E12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBL_ +FNDA:71,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error8ErrorSetEINtB1x_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ +FNDA:5,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing4bind10validation16BindingReferenceNtNtBL_5error8ErrorSetEINtB1I_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ +FNDA:3,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultbNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextbE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultdNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextdE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:126,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBK_ +FNDA:4,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageReEBK_ +FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextuE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:2,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultzNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextzE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ +FNDA:71,_RNvXs1_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_5ErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB7_4bind7command7CommandENtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4bind7BindingNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4mode5ModesNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:3,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:4,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:25,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtB1h_5types11parse_error10ParseErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8RawErrorEINtB5_12ErrorContextuE12with_contextB7_ +FNDA:2,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultzNtB5_8RawErrorEINtB5_12ErrorContextzE12with_contextB7_ +FNDA:60,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:60,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:47,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1g_6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:10,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB7_4bind7BindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:128,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueINtNtB7_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:46,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuebENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuedENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuelENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:10,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4bind12BindingInputNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:6,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode13WhenNoBindingNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:16,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode4ModeNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:13,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:90,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:71,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:5,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_4bind10validation16BindingReferenceNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ +FNDA:3,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB5_8ErrorSetEINtB5_12ErrorContextbE12with_contextB7_ +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB5_8ErrorSetEINtB5_12ErrorContextdE12with_contextB7_ +FNDA:130,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8ErrorSetEINtB5_12ErrorContextuE12with_contextB7_ +FNDA:602,_RNvXs0_NtCslo8MYDYmh8N_7parsing5errorINtNtNtCs7micvSKFzzu_4core3ops5range5RangejENtB5_9Spannable5range +FNDA:14,_RNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB6_5Error6report +FNDA:13,_RNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB6_8ErrorSet6report +FNDA:13,_RNvNtCslo8MYDYmh8N_7parsing5error12range_to_pos +FNDA:2,_RNvNtCslo8MYDYmh8N_7parsing5error38resolve_rhai_pos_from_expression_range +FNDA:8,_RNvNtCslo8MYDYmh8N_7parsing5error3err +FNDA:1,_RNvXs3_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc5boxed3BoxNtNtNtCsdKkeGZLW2Fi_4rhai5types5error13EvalAltResultEE4from +FNDA:27,_RNvXs4_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ErrorE4from +FNDA:19,_RNvXs6_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ErrorEE4from +FNDA:0,_RNvXs9_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorNtNtCs7micvSKFzzu_4core3fmt7Display3fmt +FNDA:1,_RNvXsa_NtCslo8MYDYmh8N_7parsing5errorNtB5_9CharRangeNtNtCs7micvSKFzzu_4core7default7Default7default +FNF:29 +FNH:23 +DA:46,8 +DA:47,8 +DA:48,8 +DA:71,0 +DA:72,0 +DA:73,0 +DA:77,0 +DA:78,0 +DA:79,0 +DA:83,602 +DA:84,602 +DA:85,602 +DA:97,201 +DA:98,201 +DA:99,201 +DA:100,602 +DA:101,602 +DA:102,602 +DA:104,0 +DA:106,602 +DA:111,71 +DA:112,71 +DA:113,71 +DA:114,0 +DA:115,0 +DA:116,0 +DA:117,0 +DA:118,0 +DA:119,0 +DA:122,71 +DA:128,18 +DA:129,18 +DA:130,18 +DA:131,18 +DA:132,18 +DA:133,18 +DA:137,1 +DA:138,1 +DA:139,1 +DA:159,27 +DA:160,27 +DA:161,27 +DA:162,27 +DA:163,27 +DA:167,400 +DA:168,400 +DA:169,400 +DA:171,628 +DA:172,400 +DA:173,400 +DA:174,400 +DA:175,400 +DA:177,400 +DA:178,13 +DA:180,606 +DA:182,400 +DA:185,2 +DA:186,2 +DA:187,2 +DA:188,2 +DA:189,2 +DA:193,19 +DA:194,19 +DA:195,19 +DA:200,37 +DA:201,37 +DA:202,30 +DA:203,7 +DA:204,7 +DA:205,7 +DA:206,7 +DA:207,7 +DA:208,7 +DA:209,7 +DA:212,37 +DA:217,695 +DA:218,695 +DA:219,690 +DA:220,5 +DA:221,5 +DA:222,5 +DA:223,5 +DA:224,5 +DA:227,695 +DA:237,0 +DA:238,0 +DA:239,0 +DA:240,0 +DA:241,0 +DA:243,0 +DA:244,0 +DA:248,0 +DA:249,0 +DA:250,0 +DA:253,13 +DA:256,13 +DA:257,0 +DA:258,0 +DA:259,13 +DA:260,13 +DA:261,13 +DA:262,13 +DA:263,13 +DA:264,13 +DA:266,2 +DA:267,2 +DA:268,2 +DA:269,2 +DA:270,2 +DA:271,2 +DA:272,2 +DA:273,2 +DA:274,2 +DA:275,2 +DA:276,2 +DA:277,2 +DA:278,2 +DA:279,2 +DA:280,0 +DA:281,0 +DA:282,0 +DA:283,2 +DA:289,14 +DA:290,14 +DA:291,14 +DA:292,14 +DA:293,14 +DA:294,14 +DA:295,14 +DA:296,0 +DA:297,0 +DA:298,0 +DA:300,2 +DA:301,2 +DA:302,2 +DA:303,2 +DA:304,12 +DA:306,31 +DA:307,17 +DA:308,0 +DA:309,17 +DA:313,17 +DA:314,13 +DA:315,13 +DA:316,13 +DA:317,2 +DA:318,2 +DA:319,2 +DA:320,2 +DA:321,2 +DA:322,11 +DA:323,11 +DA:324,11 +DA:325,4 +DA:329,14 +DA:330,13 +DA:331,13 +DA:332,13 +DA:333,13 +DA:335,1 +DA:336,1 +DA:337,1 +DA:338,1 +DA:339,1 +DA:340,1 +DA:341,1 +DA:343,14 +DA:348,13 +DA:349,14 +DA:350,13 +DA:361,1 +DA:362,1 +DA:363,1 +DA:364,1 +DA:365,1 +DA:366,1 +DA:379,0 +DA:380,0 +DA:381,0 +DA:382,0 +DA:383,0 +DA:384,0 +BRF:0 +BRH:0 +LF:189 +LH:149 +end_of_record +SF:src/rust/parsing/src/expression.rs +FN:233,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope17pop_command_queue0B9_ +FN:227,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope20add_to_command_queue0B9_ +FN:213,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope3get0B9_ +FN:206,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope5unset0B9_ +FN:232,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope17pop_command_queue +FN:226,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope20add_to_command_queue +FN:209,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3get +FN:191,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3set +FN:202,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope5unset +FN:175,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3new +FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_4bind12BindingInputEEEB8_ +FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB6_5value5ValueEB8_ +FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB8_4bind12BindingInputEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueINtNtB8_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuebEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuedEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1H_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_5value5ValueEEEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB8_4bind7command7CommandEEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtB6_5value5ValueEB8_ +FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtNtB8_4bind10validation10KeyBindingEB8_ +FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0Ba_ +FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtB8_5value5ValueE0Ba_ +FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuebEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuedEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1J_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_5value5ValueEEEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtB8_5value5ValueE0Ba_ +FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0Ba_ +FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope17pop_command_queue0B9_ +FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope20add_to_command_queue0B9_ +FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope3get0B9_ +FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope5unset0B9_ +FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope17pop_command_queue +FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope20add_to_command_queue +FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3get +FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3set +FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope5unset +FNDA:30,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3new +FNDA:13,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_4bind12BindingInputEEEB8_ +FNDA:6,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB6_5value5ValueEB8_ +FNDA:3,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB8_4bind12BindingInputEB8_ +FNDA:47,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueINtNtB8_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEB8_ +FNDA:64,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB8_ +FNDA:3,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuebEEB8_ +FNDA:0,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuedEEB8_ +FNDA:4,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1H_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_5value5ValueEEEEB8_ +FNDA:10,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB8_4bind7command7CommandEEB8_ +FNDA:13,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtB6_5value5ValueEB8_ +FNDA:21,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtNtB8_4bind10validation10KeyBindingEB8_ +FNDA:13,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0Ba_ +FNDA:8,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtB8_5value5ValueE0Ba_ +FNDA:9,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0Ba_ +FNDA:3,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0Ba_ +FNDA:32,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0Ba_ +FNDA:0,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuebEE0Ba_ +FNDA:0,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuedEE0Ba_ +FNDA:3,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1J_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_5value5ValueEEEE0Ba_ +FNDA:11,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0Ba_ +FNDA:13,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtB8_5value5ValueE0Ba_ +FNDA:10,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0Ba_ +FNF:14 +FNH:5 +DA:129,162 +DA:130,162 +DA:131,162 +DA:133,162 +DA:134,0 +DA:135,0 +DA:136,0 +DA:137,0 +DA:138,0 +DA:139,0 +DA:140,0 +DA:141,0 +DA:142,0 +DA:143,162 +DA:144,72 +DA:146,72 +DA:147,151 +DA:148,79 +DA:149,79 +DA:151,72 +DA:152,71 +DA:153,71 +DA:154,71 +DA:155,71 +DA:156,72 +DA:157,162 +DA:159,22 +DA:160,30 +DA:161,30 +DA:162,5 +DA:163,25 +DA:164,25 +DA:165,25 +DA:166,25 +DA:167,25 +DA:168,23 +DA:169,23 +DA:170,30 +DA:171,16 +DA:172,22 +DA:175,30 +DA:176,30 +DA:177,30 +DA:178,30 +DA:179,30 +DA:181,30 +DA:182,30 +DA:183,30 +DA:184,30 +DA:185,30 +DA:186,30 +DA:187,30 +DA:188,30 +DA:189,30 +DA:191,0 +DA:192,0 +DA:193,0 +DA:194,0 +DA:196,0 +DA:197,0 +DA:198,0 +DA:199,0 +DA:200,0 +DA:202,0 +DA:203,0 +DA:204,0 +DA:205,0 +DA:206,0 +DA:207,0 +DA:209,0 +DA:210,0 +DA:211,0 +DA:212,0 +DA:213,0 +DA:214,0 +DA:215,0 +DA:216,0 +DA:218,0 +DA:219,0 +DA:220,0 +DA:221,0 +DA:222,0 +DA:224,0 +DA:226,0 +DA:227,0 +DA:228,0 +DA:230,0 +DA:232,0 +DA:233,0 +DA:234,0 +DA:235,0 +BRF:0 +BRH:0 +LF:99 +LH:48 +end_of_record +SF:src/rust/parsing/src/expression/value.rs +FN:742,_RINvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtBa_4util6PluralpENtB6_9Expanding15map_expressionspEBa_ +FN:632,_RNCNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_9Expanding11is_constant0Bb_ +FN:406,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from0Bb_ +FN:412,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_froms_0Bb_ +FN:631,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_9Expanding11is_constantB9_ +FN:739,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtB9_4util6PluralpENtB5_9Expanding11is_constantB9_ +FN:959,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesv_0pEINtB5_10TypedValuepEINtNtB9_4util9ResolvingBT_E7resolveB9_ +FN:981,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesx_0pEINtB5_10TypedValuepENtNtB9_4util7Merging5mergeB9_ +FN:391,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from +FN:545,_RNvXs8_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtCs7micvSKFzzu_4core7default7Default7default +FN:551,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging8coalesce +FN:874,_RNvXso_NtNtCslo8MYDYmh8N_7parsing10expression5valuelINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuelEE4from +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB2l_E0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB2l_E0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueB1J_EE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2l_EEEE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3c_12BindingInput14expand_foreach00EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB38_6Define6expand0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB2l_B2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueB1J_EB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecB2l_EEB2x_16require_constant0EBa_ +FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB2x_16require_constant0EBa_ +FN:892,_RNvXsq_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4from +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2U_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4b_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB47_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2A_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3Q_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3M_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB36_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB32_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtB2i_12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB2i_12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNCNvMNtB2i_7foreachNtB2i_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3z_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB2I_IB2Z_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4G_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB4C_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2v_6Define6expand0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ +FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2D_6Define6expand0EBa_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB28_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEEENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind15BindingDocInputENtB5_9Expanding11is_constantB9_ +FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind23CombinedBindingDocInputENtB5_9Expanding11is_constantB9_ +FN:968,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ +FN:968,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_IB1m_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB31_12BindingInput14expand_foreach00EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2X_6Define6expand0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB1l_E0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB1l_E0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandIBP_NtNtNtBa_4bind7command7CommandEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtBT_6string6StringEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1l_EEEE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2c_12BindingInput14expand_foreach00EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB28_6Define6expand0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB1l_B1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYIBP_NtNtNtBa_4bind7command7CommandEB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtBT_6string6StringEB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB1x_16require_constant0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCNvYBO_B1Q_16require_constant0EBa_ +FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ +FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ValueENtB5_9Expanding11is_constantB9_ +FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB9_4bind7command7CommandENtB5_9Expanding11is_constantB9_ +FN:620,_RNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBF_10expression5value9Expanding16require_constantBF_ +FN:448,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FN:131,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_boolNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:190,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_someINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FN:186,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor12visit_stringNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:178,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_f64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:174,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:135,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapINtNtCs14aAdjk2HcL_13toml_datetime2de20DatetimeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5table14TableMapAccessEBd_ +FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18MapRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQNtNtCsbTJfyT4wEp0_4toml5value15MapDeserializerEBd_ +FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5array14ArraySeqAccessEBd_ +FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18SeqRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQNtNtCsbTJfyT4wEp0_4toml5value15SeqDeserializerEBd_ +FN:182,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_strNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:161,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:148,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ +FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ +FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2I_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1E_12BindingInput14expand_foreach00EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1A_6Define6expand0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYBO_BZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2j_3vec3VecBO_EEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEBZ_16require_constant0EBa_ +FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingBZ_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1u_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2J_12BindingInput14expand_foreach00EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2F_6Define6expand0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvYBO_B24_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1a_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2o_12BindingInput14expand_foreach00EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2k_6Define6expand0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvYBO_B1J_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEB18_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB2n_E0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB2n_E0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueB1L_EE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2n_EEEE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB3e_12BindingInput14expand_foreach00E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB3a_6Define6expand0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB2n_B2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueB1L_EB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecB2n_EEB2z_16require_constant0E0Bc_ +FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB2z_16require_constant0E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIB28_IB2p_NtNtBc_4bind12BindingInputEEE0E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB45_12BindingInput14expand_foreach00E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB41_6Define6expand0E0Bc_ +FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvYBQ_B2B_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2K_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBQ_EEEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB1G_12BindingInput14expand_foreach00E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB1C_6Define6expand0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYBQ_B11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2l_3vec3VecBQ_EEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEB11_16require_constant0E0Bc_ +FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB11_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_IB1o_NtNtBc_4bind12BindingInputEEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB33_12BindingInput14expand_foreach00E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2Z_6Define6expand0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB1n_E0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB1n_E0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandIBR_NtNtNtBc_4bind7command7CommandEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtBV_6string6StringEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1n_EEEE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB2e_12BindingInput14expand_foreach00E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2a_6Define6expand0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB1n_B1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYIBR_NtNtNtBc_4bind7command7CommandEB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtBV_6string6StringEB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB1z_16require_constant0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCNvYBQ_B1S_16require_constant0E0Bc_ +FN:253,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3new0Bb_ +FN:259,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3news_0Bb_ +FN:429,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FN:435,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FN:455,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FN:459,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FN:478,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FN:483,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FN:505,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from0Bb_ +FN:513,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_froms_0Bb_ +FN:649,_RNCNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1y_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEEENtB7_9Expanding11is_constant0Bb_ +FN:669,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constant0Bb_ +FN:670,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constants_0Bb_ +FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEENtB7_9Expanding11is_constant0Bb_ +FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB7_5ValueENtB7_9Expanding11is_constant0Bb_ +FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBb_4bind7command7CommandENtB7_9Expanding11is_constant0Bb_ +FN:625,_RNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBN_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1D_9Expanding16require_constant0B1H_ +FN:625,_RNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBH_10expression5value9Expanding16require_constant0BH_ +FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBb_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_9Expanding16require_constant0Bb_ +FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_9Expanding16require_constant0Bb_ +FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB7_9Expanding16require_constant0Bb_ +FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB7_9Expanding16require_constant0Bb_ +FN:625,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB6_9Expanding16require_constant0Ba_ +FN:625,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtBa_10expression5value9Expanding16require_constant0Ba_ +FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding11is_constantB9_ +FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtB5_9Expanding11is_constantB9_ +FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedENtB5_9Expanding11is_constantB9_ +FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtB5_9Expanding11is_constantB9_ +FN:925,_RNvXst_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE4fromB9_ +FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtB18_9ResolvingINtNtB1t_3vec3VecB1p_EE7resolveB9_ +FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtB9_4util9ResolvingB15_E7resolveB9_ +FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtB9_4util9ResolvingbE7resolveB9_ +FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtB9_4util9ResolvingdE7resolveB9_ +FN:977,_RNvXsx_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB18_7Merging8coalesceB9_ +FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding16require_constantB9_ +FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding16require_constantB9_ +FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB5_9Expanding16require_constantB9_ +FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB5_9Expanding16require_constantB9_ +FN:620,_RNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB4_9Expanding16require_constantB8_ +FN:245,_RNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5Value3new +FN:363,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value16interp_to_string +FN:269,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value19match_to_expression +FN:332,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value20string_to_expression +FN:305,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value22check_unmatched_braces +FN:61,_RNvXNtNtCslo8MYDYmh8N_7parsing10expression5valueNtB2_10ExpressionNtNtCs7micvSKFzzu_4core3fmt7Display3fmt +FN:127,_RNvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB2_12ValueVisitorNtB17_7Visitor9expecting +FN:422,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FN:497,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from +FN:554,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging5merge +FN:70,_RNvXs_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB4_10ExpressionNtNtCs7micvSKFzzu_4core3cmp9PartialEq2eq +FN:583,_RNvXsa_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingBN_E7resolve +FN:589,_RNvXsb_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolve +FN:665,_RNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtB5_9Expanding11is_constant +FN:883,_RNvXsp_NtNtCslo8MYDYmh8N_7parsing10expression5valuedINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuedEE4from +FN:901,_RNvXsr_NtNtCslo8MYDYmh8N_7parsing10expression5valuebINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuebEE4from +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2i_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3y_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3u_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1Y_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3d_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB39_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2k_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3A_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3w_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB22_12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB22_12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNCNvMNtB22_7foreachNtB22_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3d_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB3x_3vec3VecBO_EEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2t_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2p_6Define6expand0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecBO_EE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB1G_12BindingInputEEE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1G_12BindingInputE0EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNCNvMNtB1G_7foreachNtB1G_12BindingInput14expand_foreach00EBa_ +FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2W_6Define6expand0EBa_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingEENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueENtB5_9Expanding11is_constantB9_ +FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceENtB5_9Expanding11is_constantB9_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2L_12BindingInput14expand_foreach00EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2H_6Define6expand0EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1e_12BindingInputEEE0EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1e_12BindingInputE0EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNCNvMNtB1e_7foreachNtB1e_12BindingInput14expand_foreach00EBa_ +FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2o_6Define6expand0EBa_ +FN:751,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FN:751,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB5_9Expanding11is_constantB9_ +FN:913,_RNvXss_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4fromB9_ +FN:620,_RNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtB8_10expression5value9Expanding16require_constantB8_ +FN:991,_RNvNtNtNtCslo8MYDYmh8N_7parsing10expression5value5testss_14parse_datetime +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB26_IB2n_NtNtBa_4bind12BindingInputEEE0EBa_ +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB43_12BindingInput14expand_foreach00EBa_ +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3Z_6Define6expand0EBa_ +FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvYBO_B2z_16require_constant0EBa_ +FN:648,_RNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEENtB5_9Expanding11is_constantB9_ +FN:620,_RNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBL_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1B_9Expanding16require_constantB1F_ +FN:471,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FNDA:0,_RINvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtBa_4util6PluralpENtB6_9Expanding15map_expressionspEBa_ +FNDA:0,_RNCNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_9Expanding11is_constant0Bb_ +FNDA:0,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from0Bb_ +FNDA:0,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_froms_0Bb_ +FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtB9_4util6PluralpENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesv_0pEINtB5_10TypedValuepEINtNtB9_4util9ResolvingBT_E7resolveB9_ +FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesx_0pEINtB5_10TypedValuepENtNtB9_4util7Merging5mergeB9_ +FNDA:0,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from +FNDA:0,_RNvXs8_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtCs7micvSKFzzu_4core7default7Default7default +FNDA:0,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging8coalesce +FNDA:0,_RNvXso_NtNtCslo8MYDYmh8N_7parsing10expression5valuelINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuelEE4from +FNDA:6,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB2l_E0EBa_ +FNDA:9,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:13,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB2l_E0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueB1J_EE0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEE0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FNDA:10,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2l_EEEE0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FNDA:34,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3c_12BindingInput14expand_foreach00EBa_ +FNDA:14,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB38_6Define6expand0EBa_ +FNDA:13,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB2l_B2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueB1J_EB2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEB2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB2x_16require_constant0EBa_ +FNDA:10,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEB2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecB2l_EEB2x_16require_constant0EBa_ +FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB2x_16require_constant0EBa_ +FNDA:68,_RNvXsq_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4from +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2U_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4b_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB47_6Define6expand0EBa_ +FNDA:22,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2A_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:12,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:136,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3Q_12BindingInput14expand_foreach00EBa_ +FNDA:28,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3M_6Define6expand0EBa_ +FNDA:18,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:9,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:102,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FNDA:23,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB36_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB32_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtB2i_12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB2i_12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNCNvMNtB2i_7foreachNtB2i_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3z_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB2I_IB2Z_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4G_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB4C_6Define6expand0EBa_ +FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2v_6Define6expand0EBa_ +FNDA:4,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ +FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ +FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ +FNDA:5,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2D_6Define6expand0EBa_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_9Expanding11is_constantB9_ +FNDA:6,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FNDA:5,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB28_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind15BindingDocInputENtB5_9Expanding11is_constantB9_ +FNDA:1,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind23CombinedBindingDocInputENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ +FNDA:19,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ +FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_IB1m_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EE0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB31_12BindingInput14expand_foreach00EBa_ +FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2X_6Define6expand0EBa_ +FNDA:13,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ +FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB1l_E0EBa_ +FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:4,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:4,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB1l_E0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandIBP_NtNtNtBa_4bind7command7CommandEE0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEE0EBa_ +FNDA:27,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtBT_6string6StringEE0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1l_EEEE0EBa_ +FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FNDA:52,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2c_12BindingInput14expand_foreach00EBa_ +FNDA:8,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB28_6Define6expand0EBa_ +FNDA:8,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB1l_B1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYIBP_NtNtNtBa_4bind7command7CommandEB1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEB1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtBT_6string6StringEB1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB1x_16require_constant0EBa_ +FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EB1x_16require_constant0EBa_ +FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB1x_16require_constant0EBa_ +FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCNvYBO_B1Q_16require_constant0EBa_ +FNDA:0,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ +FNDA:103,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ValueENtB5_9Expanding11is_constantB9_ +FNDA:10,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB9_4bind7command7CommandENtB5_9Expanding11is_constantB9_ +FNDA:10,_RNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBF_10expression5value9Expanding16require_constantBF_ +FNDA:157,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FNDA:3,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_boolNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_someINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FNDA:70,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor12visit_stringNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_f64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:28,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:1,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapINtNtCs14aAdjk2HcL_13toml_datetime2de20DatetimeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FNDA:60,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5table14TableMapAccessEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18MapRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQNtNtCsbTJfyT4wEp0_4toml5value15MapDeserializerEBd_ +FNDA:11,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5array14ArraySeqAccessEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18SeqRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ +FNDA:3,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQNtNtCsbTJfyT4wEp0_4toml5value15SeqDeserializerEBd_ +FNDA:57,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_strNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ +FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:72,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ +FNDA:7,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ +FNDA:39,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ +FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ +FNDA:77,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ +FNDA:7,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ +FNDA:149,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ +FNDA:16,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ +FNDA:37,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:25,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:3,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0EBa_ +FNDA:90,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ +FNDA:7,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2I_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0EBa_ +FNDA:21,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FNDA:30,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ +FNDA:228,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1E_12BindingInput14expand_foreach00EBa_ +FNDA:53,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1A_6Define6expand0EBa_ +FNDA:119,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYBO_BZ_16require_constant0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEBZ_16require_constant0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEBZ_16require_constant0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEBZ_16require_constant0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEBZ_16require_constant0EBa_ +FNDA:34,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2j_3vec3VecBO_EEBZ_16require_constant0EBa_ +FNDA:21,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEBZ_16require_constant0EBa_ +FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingBZ_16require_constant0EBa_ +FNDA:24,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1u_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:6,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:47,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:68,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2J_12BindingInput14expand_foreach00EBa_ +FNDA:30,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2F_6Define6expand0EBa_ +FNDA:46,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvYBO_B24_16require_constant0EBa_ +FNDA:14,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1a_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:6,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:64,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:68,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2o_12BindingInput14expand_foreach00EBa_ +FNDA:17,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2k_6Define6expand0EBa_ +FNDA:64,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvYBO_B1J_16require_constant0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:3,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:10,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FNDA:3,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ +FNDA:10,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEB18_16require_constant0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ +FNDA:6,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB2n_E0E0Bc_ +FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FNDA:4,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB2n_E0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueB1L_EE0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEE0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FNDA:11,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2n_EEEE0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FNDA:34,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB3e_12BindingInput14expand_foreach00E0Bc_ +FNDA:20,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB3a_6Define6expand0E0Bc_ +FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB2n_B2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueB1L_EB2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEB2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB2z_16require_constant0E0Bc_ +FNDA:11,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEB2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecB2n_EEB2z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB2z_16require_constant0E0Bc_ +FNDA:2,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIB28_IB2p_NtNtBc_4bind12BindingInputEEE0E0Bc_ +FNDA:3,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FNDA:5,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FNDA:0,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB45_12BindingInput14expand_foreach00E0Bc_ +FNDA:2,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB41_6Define6expand0E0Bc_ +FNDA:5,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvYBQ_B2B_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FNDA:8,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0E0Bc_ +FNDA:62,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2K_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBQ_EEEE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ +FNDA:20,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB1G_12BindingInput14expand_foreach00E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB1C_6Define6expand0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYBQ_B11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2l_3vec3VecBQ_EEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEB11_16require_constant0E0Bc_ +FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB11_16require_constant0E0Bc_ +FNDA:2,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_IB1o_NtNtBc_4bind12BindingInputEEE0E0Bc_ +FNDA:5,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FNDA:7,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EE0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB33_12BindingInput14expand_foreach00E0Bc_ +FNDA:2,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2Z_6Define6expand0E0Bc_ +FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ +FNDA:4,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB1n_E0E0Bc_ +FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ +FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ +FNDA:8,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB1n_E0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandIBR_NtNtNtBc_4bind7command7CommandEE0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEE0E0Bc_ +FNDA:62,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtBV_6string6StringEE0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1n_EEEE0E0Bc_ +FNDA:20,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ +FNDA:112,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB2e_12BindingInput14expand_foreach00E0Bc_ +FNDA:16,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2a_6Define6expand0E0Bc_ +FNDA:17,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB1n_B1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYIBR_NtNtNtBc_4bind7command7CommandEB1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEB1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtBV_6string6StringEB1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB1z_16require_constant0E0Bc_ +FNDA:34,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EB1z_16require_constant0E0Bc_ +FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB1z_16require_constant0E0Bc_ +FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ +FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCNvYBQ_B1S_16require_constant0E0Bc_ +FNDA:29,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3new0Bb_ +FNDA:86,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3news_0Bb_ +FNDA:0,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FNDA:0,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FNDA:10,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FNDA:24,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FNDA:0,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ +FNDA:0,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ +FNDA:35,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from0Bb_ +FNDA:0,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_froms_0Bb_ +FNDA:0,_RNCNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1y_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEEENtB7_9Expanding11is_constant0Bb_ +FNDA:7,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constant0Bb_ +FNDA:13,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constants_0Bb_ +FNDA:0,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEENtB7_9Expanding11is_constant0Bb_ +FNDA:214,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB7_5ValueENtB7_9Expanding11is_constant0Bb_ +FNDA:10,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBb_4bind7command7CommandENtB7_9Expanding11is_constant0Bb_ +FNDA:0,_RNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBN_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1D_9Expanding16require_constant0B1H_ +FNDA:0,_RNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBH_10expression5value9Expanding16require_constant0BH_ +FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBb_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_9Expanding16require_constant0Bb_ +FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_9Expanding16require_constant0Bb_ +FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB7_9Expanding16require_constant0Bb_ +FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB7_9Expanding16require_constant0Bb_ +FNDA:12,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB6_9Expanding16require_constant0Ba_ +FNDA:0,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtBa_10expression5value9Expanding16require_constant0Ba_ +FNDA:58,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FNDA:4,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FNDA:19,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ +FNDA:10,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FNDA:50,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FNDA:3,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FNDA:1,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FNDA:1,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ +FNDA:10,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FNDA:50,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FNDA:11,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FNDA:1,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FNDA:1,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ +FNDA:6,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding11is_constantB9_ +FNDA:10,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtB5_9Expanding11is_constantB9_ +FNDA:2,_RNvXst_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE4fromB9_ +FNDA:47,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtB18_9ResolvingINtNtB1t_3vec3VecB1p_EE7resolveB9_ +FNDA:64,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtB9_4util9ResolvingB15_E7resolveB9_ +FNDA:3,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtB9_4util9ResolvingbE7resolveB9_ +FNDA:0,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtB9_4util9ResolvingdE7resolveB9_ +FNDA:12,_RNvXsx_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB18_7Merging8coalesceB9_ +FNDA:46,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding16require_constantB9_ +FNDA:64,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding16require_constantB9_ +FNDA:3,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB5_9Expanding16require_constantB9_ +FNDA:0,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB5_9Expanding16require_constantB9_ +FNDA:89,_RNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB4_9Expanding16require_constantB8_ +FNDA:312,_RNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5Value3new +FNDA:0,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value16interp_to_string +FNDA:35,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value19match_to_expression +FNDA:190,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value20string_to_expression +FNDA:158,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value22check_unmatched_braces +FNDA:83,_RNvXNtNtCslo8MYDYmh8N_7parsing10expression5valueNtB2_10ExpressionNtNtCs7micvSKFzzu_4core3fmt7Display3fmt +FNDA:0,_RNvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB2_12ValueVisitorNtB17_7Visitor9expecting +FNDA:102,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FNDA:106,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from +FNDA:11,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging5merge +FNDA:3,_RNvXs_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB4_10ExpressionNtNtCs7micvSKFzzu_4core3cmp9PartialEq2eq +FNDA:5,_RNvXsa_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingBN_E7resolve +FNDA:13,_RNvXsb_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolve +FNDA:329,_RNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtB5_9Expanding11is_constant +FNDA:1,_RNvXsp_NtNtCslo8MYDYmh8N_7parsing10expression5valuedINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuedEE4from +FNDA:13,_RNvXsr_NtNtCslo8MYDYmh8N_7parsing10expression5valuebINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuebEE4from +FNDA:24,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2i_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:6,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:68,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3y_12BindingInput14expand_foreach00EBa_ +FNDA:30,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3u_6Define6expand0EBa_ +FNDA:4,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1Y_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3d_12BindingInput14expand_foreach00EBa_ +FNDA:5,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB39_6Define6expand0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ +FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2k_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3A_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3w_6Define6expand0EBa_ +FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB22_12BindingInputEEE0EBa_ +FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB22_12BindingInputE0EBa_ +FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNCNvMNtB22_7foreachNtB22_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3d_6Define6expand0EBa_ +FNDA:7,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:8,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:7,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB3x_3vec3VecBO_EEE0EBa_ +FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2t_12BindingInput14expand_foreach00EBa_ +FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2p_6Define6expand0EBa_ +FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecBO_EE0EBa_ +FNDA:2,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB1G_12BindingInputEEE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1G_12BindingInputE0EBa_ +FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNCNvMNtB1G_7foreachNtB1G_12BindingInput14expand_foreach00EBa_ +FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2W_6Define6expand0EBa_ +FNDA:6,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FNDA:1,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEENtB5_9Expanding11is_constantB9_ +FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingEENtB5_9Expanding11is_constantB9_ +FNDA:2,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueENtB5_9Expanding11is_constantB9_ +FNDA:1,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceENtB5_9Expanding11is_constantB9_ +FNDA:10,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:3,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:34,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2L_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2H_6Define6expand0EBa_ +FNDA:10,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1e_12BindingInputEEE0EBa_ +FNDA:3,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1e_12BindingInputE0EBa_ +FNDA:34,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNCNvMNtB1e_7foreachNtB1e_12BindingInput14expand_foreach00EBa_ +FNDA:13,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2o_6Define6expand0EBa_ +FNDA:3,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ +FNDA:3,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB5_9Expanding11is_constantB9_ +FNDA:46,_RNvXss_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4fromB9_ +FNDA:21,_RNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtB8_10expression5value9Expanding16require_constantB8_ +FNDA:1,_RNvNtNtNtCslo8MYDYmh8N_7parsing10expression5value5testss_14parse_datetime +FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB26_IB2n_NtNtBa_4bind12BindingInputEEE0EBa_ +FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ +FNDA:4,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ +FNDA:0,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB43_12BindingInput14expand_foreach00EBa_ +FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3Z_6Define6expand0EBa_ +FNDA:4,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvYBO_B2z_16require_constant0EBa_ +FNDA:0,_RNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEENtB5_9Expanding11is_constantB9_ +FNDA:4,_RNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBL_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1B_9Expanding16require_constantB1F_ +FNDA:82,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from +FNF:87 +FNH:61 +DA:61,83 +DA:62,83 +DA:63,83 +DA:64,83 +DA:65,83 +DA:66,83 +DA:70,3 +DA:71,3 +DA:72,0 +DA:73,3 +DA:75,3 +DA:76,3 +DA:77,3 +DA:78,3 +DA:86,118 +DA:87,118 +DA:88,118 +DA:90,118 +DA:91,118 +DA:94,0 +DA:95,118 +DA:97,118 +DA:118,233 +DA:119,233 +DA:120,233 +DA:127,0 +DA:128,0 +DA:129,0 +DA:131,3 +DA:132,3 +DA:133,3 +DA:135,28 +DA:136,28 +DA:137,28 +DA:138,28 +DA:139,28 +DA:140,28 +DA:142,0 +DA:143,0 +DA:144,0 +DA:146,28 +DA:148,0 +DA:149,0 +DA:150,0 +DA:151,0 +DA:152,0 +DA:153,0 +DA:155,0 +DA:156,0 +DA:157,0 +DA:159,0 +DA:161,0 +DA:162,0 +DA:163,0 +DA:164,0 +DA:165,0 +DA:166,0 +DA:168,0 +DA:169,0 +DA:170,0 +DA:172,0 +DA:174,0 +DA:175,0 +DA:176,0 +DA:178,0 +DA:179,0 +DA:180,0 +DA:182,57 +DA:183,57 +DA:184,57 +DA:186,70 +DA:187,70 +DA:188,70 +DA:190,0 +DA:191,0 +DA:192,0 +DA:194,0 +DA:195,0 +DA:197,14 +DA:198,14 +DA:199,14 +DA:201,14 +DA:202,43 +DA:203,29 +DA:204,29 +DA:205,14 +DA:206,14 +DA:208,61 +DA:209,61 +DA:210,61 +DA:212,61 +DA:213,1 +DA:214,1 +DA:216,0 +DA:217,60 +DA:219,60 +DA:220,60 +DA:221,86 +DA:222,26 +DA:223,26 +DA:224,26 +DA:226,0 +DA:227,0 +DA:228,0 +DA:232,60 +DA:233,61 +DA:236,233 +DA:237,233 +DA:245,312 +DA:246,312 +DA:247,3 +DA:248,0 +DA:249,44 +DA:250,1 +DA:251,190 +DA:252,14 +DA:253,29 +DA:254,29 +DA:255,29 +DA:256,14 +DA:258,60 +DA:259,86 +DA:260,86 +DA:261,86 +DA:262,86 +DA:263,60 +DA:266,312 +DA:269,35 +DA:270,35 +DA:271,14 +DA:272,14 +DA:273,14 +DA:274,14 +DA:275,14 +DA:276,2 +DA:277,2 +DA:278,2 +DA:280,12 +DA:281,14 +DA:282,14 +DA:283,14 +DA:284,14 +DA:285,14 +DA:286,14 +DA:288,21 +DA:289,21 +DA:290,21 +DA:291,0 +DA:292,0 +DA:293,0 +DA:294,0 +DA:295,21 +DA:296,21 +DA:297,21 +DA:298,21 +DA:299,21 +DA:300,21 +DA:301,21 +DA:303,35 +DA:305,158 +DA:306,158 +DA:307,0 +DA:308,0 +DA:309,0 +DA:310,0 +DA:312,0 +DA:313,0 +DA:314,0 +DA:315,0 +DA:317,158 +DA:318,3 +DA:319,3 +DA:320,3 +DA:321,3 +DA:323,3 +DA:324,3 +DA:325,3 +DA:326,3 +DA:328,155 +DA:329,155 +DA:330,158 +DA:332,190 +DA:333,190 +DA:335,190 +DA:336,190 +DA:339,200 +DA:340,35 +DA:341,35 +DA:342,25 +DA:343,10 +DA:344,10 +DA:345,8 +DA:346,8 +DA:347,10 +DA:349,10 +DA:350,10 +DA:351,10 +DA:352,0 +DA:354,165 +DA:355,156 +DA:356,9 +DA:357,9 +DA:358,2 +DA:359,7 +DA:360,9 +DA:361,190 +DA:363,0 +DA:364,0 +DA:365,0 +DA:366,0 +DA:367,0 +DA:368,0 +DA:369,0 +DA:370,0 +DA:371,0 +DA:372,0 +DA:373,0 +DA:374,0 +DA:375,0 +DA:376,0 +DA:378,0 +DA:382,0 +DA:383,0 +DA:391,0 +DA:392,0 +DA:393,0 +DA:394,0 +DA:395,0 +DA:396,0 +DA:397,0 +DA:399,0 +DA:403,0 +DA:404,0 +DA:405,0 +DA:406,0 +DA:407,0 +DA:408,0 +DA:409,0 +DA:411,0 +DA:412,0 +DA:413,0 +DA:414,0 +DA:415,0 +DA:418,0 +DA:422,102 +DA:423,102 +DA:424,0 +DA:425,0 +DA:426,0 +DA:428,0 +DA:429,0 +DA:430,0 +DA:432,0 +DA:433,0 +DA:434,0 +DA:435,0 +DA:436,0 +DA:437,0 +DA:439,0 +DA:440,0 +DA:441,16 +DA:442,86 +DA:444,102 +DA:448,157 +DA:449,157 +DA:450,0 +DA:451,0 +DA:452,0 +DA:454,5 +DA:455,10 +DA:456,5 +DA:458,23 +DA:459,24 +DA:460,23 +DA:462,10 +DA:463,0 +DA:464,10 +DA:465,109 +DA:467,157 +DA:471,82 +DA:472,82 +DA:473,0 +DA:474,16 +DA:475,0 +DA:476,66 +DA:477,0 +DA:478,0 +DA:479,0 +DA:481,0 +DA:482,0 +DA:483,0 +DA:484,0 +DA:487,0 +DA:488,0 +DA:490,82 +DA:497,106 +DA:498,106 +DA:499,0 +DA:500,106 +DA:501,5 +DA:502,5 +DA:503,5 +DA:504,5 +DA:505,35 +DA:506,5 +DA:507,5 +DA:508,101 +DA:509,0 +DA:510,0 +DA:511,0 +DA:512,0 +DA:513,0 +DA:514,0 +DA:515,0 +DA:516,101 +DA:517,0 +DA:518,101 +DA:519,0 +DA:520,101 +DA:521,9 +DA:522,9 +DA:523,0 +DA:524,92 +DA:525,0 +DA:526,92 +DA:527,92 +DA:528,92 +DA:529,92 +DA:530,92 +DA:531,92 +DA:532,92 +DA:533,92 +DA:535,0 +DA:537,106 +DA:545,0 +DA:546,0 +DA:547,0 +DA:551,0 +DA:552,0 +DA:553,0 +DA:554,11 +DA:555,11 +DA:556,1 +DA:557,1 +DA:558,1 +DA:559,1 +DA:560,1 +DA:562,3 +DA:563,3 +DA:564,3 +DA:565,1 +DA:566,2 +DA:567,2 +DA:569,1 +DA:571,0 +DA:573,8 +DA:574,8 +DA:575,0 +DA:577,2 +DA:579,11 +DA:583,5 +DA:584,5 +DA:585,5 +DA:589,13 +DA:590,13 +DA:591,13 +DA:592,13 +DA:593,13 +DA:594,13 +DA:620,237 +DA:621,237 +DA:622,237 +DA:624,237 +DA:625,237 +DA:626,226 +DA:627,237 +DA:631,0 +DA:632,0 +DA:633,0 +DA:634,112 +DA:635,112 +DA:636,112 +DA:638,112 +DA:639,112 +DA:640,125 +DA:641,6 +DA:642,106 +DA:643,106 +DA:644,112 +DA:648,0 +DA:649,0 +DA:650,0 +DA:651,14 +DA:652,14 +DA:653,14 +DA:655,14 +DA:656,14 +DA:657,17 +DA:658,0 +DA:659,14 +DA:660,14 +DA:661,14 +DA:665,329 +DA:666,329 +DA:667,72 +DA:668,45 +DA:669,7 +DA:670,13 +DA:671,196 +DA:673,329 +DA:674,718 +DA:675,718 +DA:676,718 +DA:678,718 +DA:679,216 +DA:680,110 +DA:681,110 +DA:682,103 +DA:683,90 +DA:684,82 +DA:685,8 +DA:686,8 +DA:687,8 +DA:688,8 +DA:689,8 +DA:691,90 +DA:692,41 +DA:694,62 +DA:697,10 +DA:698,112 +DA:699,270 +DA:702,270 +DA:704,718 +DA:709,16 +DA:710,16 +DA:711,16 +DA:712,375 +DA:713,375 +DA:714,375 +DA:716,375 +DA:717,375 +DA:718,375 +DA:719,375 +DA:721,375 +DA:725,113 +DA:726,224 +DA:727,113 +DA:728,170 +DA:729,170 +DA:730,170 +DA:732,170 +DA:733,339 +DA:734,7 +DA:735,170 +DA:739,0 +DA:740,0 +DA:741,0 +DA:742,0 +DA:743,0 +DA:744,0 +DA:746,0 +DA:747,0 +DA:751,6 +DA:752,6 +DA:753,3 +DA:754,3 +DA:756,6 +DA:757,120 +DA:758,120 +DA:759,120 +DA:761,120 +DA:762,31 +DA:763,89 +DA:765,120 +DA:769,33 +DA:770,33 +DA:771,28 +DA:772,5 +DA:774,33 +DA:775,816 +DA:776,816 +DA:777,816 +DA:779,816 +DA:780,655 +DA:781,161 +DA:783,816 +DA:806,81 +DA:807,81 +DA:808,81 +DA:816,65 +DA:817,65 +DA:819,65 +DA:820,65 +DA:821,65 +DA:829,73 +DA:830,73 +DA:831,73 +DA:832,11 +DA:834,62 +DA:835,62 +DA:836,62 +DA:839,73 +DA:846,19 +DA:847,19 +DA:848,19 +DA:849,0 +DA:851,19 +DA:852,480 +DA:853,480 +DA:854,480 +DA:856,480 +DA:857,84 +DA:858,84 +DA:859,83 +DA:861,30 +DA:862,30 +DA:863,30 +DA:865,53 +DA:868,396 +DA:870,480 +DA:874,0 +DA:875,0 +DA:876,0 +DA:877,0 +DA:879,0 +DA:883,1 +DA:884,1 +DA:885,1 +DA:886,0 +DA:888,1 +DA:892,68 +DA:893,68 +DA:894,68 +DA:895,0 +DA:897,68 +DA:901,13 +DA:902,13 +DA:903,13 +DA:904,0 +DA:906,13 +DA:913,46 +DA:914,46 +DA:915,46 +DA:916,0 +DA:918,46 +DA:925,2 +DA:926,2 +DA:927,2 +DA:928,2 +DA:933,2 +DA:935,0 +DA:937,2 +DA:946,114 +DA:947,114 +DA:948,113 +DA:949,113 +DA:950,113 +DA:951,113 +DA:952,114 +DA:959,0 +DA:960,0 +DA:961,0 +DA:968,19 +DA:969,19 +DA:970,0 +DA:971,19 +DA:973,19 +DA:977,12 +DA:978,12 +DA:979,12 +DA:981,0 +DA:982,0 +DA:983,0 +DA:991,1 +DA:992,1 +DA:993,1 +DA:994,1 +DA:995,1 +DA:996,1 +DA:997,1 +BRF:0 +BRH:0 +LF:605 +LH:409 +end_of_record +SF:src/rust/parsing/src/file.rs +FN:226,_RNCNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes0B5_ +FN:218,_RNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes +FN:179,_RNCNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB6_7KeyFile3news1_00B8_ +FN:135,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3new0B6_ +FN:162,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news0_0B6_ +FN:166,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news1_0B6_ +FN:149,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news_0B6_ +FN:119,_RNvMNtCslo8MYDYmh8N_7parsing4fileNtB2_7KeyFile3new +FN:231,_RNvNtCslo8MYDYmh8N_7parsing4file18parse_bytes_helper +FN:392,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreach0B7_ +FN:393,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreachs_0B7_ +FN:582,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressions0B7_ +FN:584,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss0_0B7_ +FN:585,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss1_0B7_ +FN:586,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss2_0B7_ +FN:587,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss3_0B7_ +FN:583,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss_0B7_ +FNDA:0,_RNCNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes0B5_ +FNDA:0,_RNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes +FNDA:19,_RNCNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB6_7KeyFile3news1_00B8_ +FNDA:5,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3new0B6_ +FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news0_0B6_ +FNDA:10,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news1_0B6_ +FNDA:10,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news_0B6_ +FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing4fileNtB2_7KeyFile3new +FNDA:1,_RNvNtCslo8MYDYmh8N_7parsing4file18parse_bytes_helper +FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreach0B7_ +FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreachs_0B7_ +FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressions0B7_ +FNDA:1,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss0_0B7_ +FNDA:1,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss1_0B7_ +FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss2_0B7_ +FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss3_0B7_ +FNDA:3,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss_0B7_ +FNF:17 +FNH:14 +DA:119,13 +DA:120,13 +DA:123,13 +DA:124,13 +DA:125,0 +DA:126,0 +DA:127,0 +DA:129,13 +DA:133,13 +DA:134,13 +DA:135,13 +DA:136,13 +DA:137,4 +DA:138,4 +DA:139,4 +DA:141,9 +DA:145,13 +DA:146,13 +DA:147,13 +DA:148,13 +DA:149,13 +DA:151,13 +DA:152,0 +DA:153,0 +DA:154,0 +DA:156,13 +DA:159,13 +DA:160,13 +DA:161,13 +DA:162,13 +DA:164,13 +DA:165,13 +DA:166,13 +DA:167,10 +DA:168,10 +DA:169,10 +DA:177,10 +DA:178,10 +DA:179,19 +DA:180,10 +DA:181,10 +DA:182,10 +DA:183,8 +DA:184,2 +DA:185,2 +DA:186,2 +DA:190,0 +DA:191,0 +DA:192,0 +DA:195,10 +DA:196,13 +DA:198,13 +DA:199,7 +DA:200,7 +DA:201,7 +DA:202,7 +DA:203,7 +DA:205,6 +DA:207,13 +DA:218,0 +DA:219,0 +DA:220,0 +DA:221,0 +DA:222,0 +DA:223,0 +DA:224,0 +DA:225,0 +DA:226,0 +DA:229,0 +DA:231,1 +DA:232,1 +DA:233,1 +DA:234,1 +DA:235,1 +DA:392,9 +DA:393,9 +DA:582,2 +DA:583,3 +DA:584,1 +DA:585,1 +DA:586,2 +DA:587,2 +BRF:0 +BRH:0 +LF:88 +LH:67 +end_of_record +SF:src/rust/parsing/src/mode.rs +FN:309,_RNvXs6_NtCslo8MYDYmh8N_7parsing4modeNtB5_9ModeInputINtNtB7_4util9ResolvingNtB5_4ModeE7resolve +FN:294,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3get +FN:211,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3new +FN:184,_RNvMsp_NtCslo8MYDYmh8N_7parsing4modeNtB5_4Mode3new +FN:105,_RNvXNtCslo8MYDYmh8N_7parsing4modeNtB2_9ModeInputNtNtCs7micvSKFzzu_4core7default7Default7default +FN:172,_RNvXs3_NtCslo8MYDYmh8N_7parsing4modeNtB5_18WhenNoBindingInputINtNtB7_4util9ResolvingNtB5_13WhenNoBindingE7resolve +FN:300,_RNvXs5_NtCslo8MYDYmh8N_7parsing4modeNtB5_5ModesNtNtCs7micvSKFzzu_4core7default7Default7default +FN:247,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3new00Bb_ +FN:256,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_00Bb_ +FN:267,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s0_0Bb_ +FN:260,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s_0Bb_ +FN:244,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3new0B9_ +FN:253,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3news_0B9_ +FNDA:0,_RNvXs6_NtCslo8MYDYmh8N_7parsing4modeNtB5_9ModeInputINtNtB7_4util9ResolvingNtB5_4ModeE7resolve +FNDA:1,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3get +FNDA:13,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3new +FNDA:16,_RNvMsp_NtCslo8MYDYmh8N_7parsing4modeNtB5_4Mode3new +FNDA:5,_RNvXNtCslo8MYDYmh8N_7parsing4modeNtB2_9ModeInputNtNtCs7micvSKFzzu_4core7default7Default7default +FNDA:6,_RNvXs3_NtCslo8MYDYmh8N_7parsing4modeNtB5_18WhenNoBindingInputINtNtB7_4util9ResolvingNtB5_13WhenNoBindingE7resolve +FNDA:4,_RNvXs5_NtCslo8MYDYmh8N_7parsing4modeNtB5_5ModesNtNtCs7micvSKFzzu_4core7default7Default7default +FNDA:3,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3new00Bb_ +FNDA:2,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_00Bb_ +FNDA:3,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s0_0Bb_ +FNDA:6,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s_0Bb_ +FNDA:1,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3new0B9_ +FNDA:2,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3news_0B9_ +FNF:13 +FNH:12 +DA:105,5 +DA:106,5 +DA:107,5 +DA:108,5 +DA:109,5 +DA:110,5 +DA:111,5 +DA:112,5 +DA:113,5 +DA:172,6 +DA:173,6 +DA:174,0 +DA:175,5 +DA:176,1 +DA:177,0 +DA:179,6 +DA:184,16 +DA:185,16 +DA:186,7 +DA:187,7 +DA:188,2 +DA:189,1 +DA:190,1 +DA:191,5 +DA:192,9 +DA:194,15 +DA:195,15 +DA:196,15 +DA:197,15 +DA:198,15 +DA:200,16 +DA:211,13 +DA:213,13 +DA:214,13 +DA:215,13 +DA:216,33 +DA:217,22 +DA:218,0 +DA:219,22 +DA:220,22 +DA:221,22 +DA:222,1 +DA:223,21 +DA:224,21 +DA:225,13 +DA:226,1 +DA:227,1 +DA:228,12 +DA:229,12 +DA:230,8 +DA:231,20 +DA:233,11 +DA:236,1 +DA:237,10 +DA:240,10 +DA:241,10 +DA:243,10 +DA:244,10 +DA:245,1 +DA:246,1 +DA:247,3 +DA:248,1 +DA:249,1 +DA:250,10 +DA:251,10 +DA:253,2 +DA:254,2 +DA:255,2 +DA:256,2 +DA:257,2 +DA:258,2 +DA:259,8 +DA:260,6 +DA:261,5 +DA:262,5 +DA:264,2 +DA:265,1 +DA:266,1 +DA:267,3 +DA:268,1 +DA:269,1 +DA:270,0 +DA:272,1 +DA:273,1 +DA:274,1 +DA:275,2 +DA:279,10 +DA:280,25 +DA:281,16 +DA:282,16 +DA:283,16 +DA:284,16 +DA:288,9 +DA:289,9 +DA:290,9 +DA:291,9 +DA:292,13 +DA:294,1 +DA:295,1 +DA:296,1 +DA:300,4 +DA:301,4 +DA:302,4 +DA:303,4 +DA:304,4 +DA:305,4 +DA:309,0 +DA:310,0 +DA:311,0 +BRF:0 +BRH:0 +LF:114 +LH:107 +end_of_record +SF:src/rust/parsing/src/util.rs +FN:348,_RINvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB6_8RequiredpE3mapppEB8_ +FN:66,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merge0B9_ +FN:69,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merges_0B9_ +FN:36,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merge0B6_ +FN:37,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merges_0B6_ +FN:358,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE2orB7_ +FN:341,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE6as_refB7_ +FN:64,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging5mergeB7_ +FN:61,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ +FN:87,_RNvXININtCslo8MYDYmh8N_7parsing4utils2_0pEINtB5_8RequiredpENtB5_7Merging5mergeB7_ +FN:109,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging5mergeB7_ +FN:113,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging8coalesceB7_ +FN:217,_RNvXININtCslo8MYDYmh8N_7parsing4utils9_0pEINtB5_6SubsetpEINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecpEE4fromB7_ +FN:46,_RNvXININtCslo8MYDYmh8N_7parsing4utils_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ +FN:405,_RNvXININtCslo8MYDYmh8N_7parsing4utilso_0pEINtNtCsktekB2AySAD_5alloc3vec3VecpEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_6PluralpEE4fromB7_ +FN:34,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging5merge +FN:30,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging8coalesce +FN:123,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging5merge +FN:127,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging8coalesce +FN:133,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging5merge +FN:137,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging8coalesce +FN:159,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging5merge +FN:162,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging8coalesce +FN:171,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging5merge +FN:168,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging8coalesce +FN:49,_RNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueENtB4_7Merging5mergeB6_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_7Merging8coalesceB7_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEENtB5_7Merging8coalesceB7_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEENtB5_7Merging8coalesceB7_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuelEEENtB5_7Merging8coalesceB7_ +FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEENtB5_7Merging5mergeB7_ +FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_4bind10validation16BindingReferenceEENtB5_7Merging8coalesceB7_ +FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind15BindingDocInputENtB5_7Merging5mergeB7_ +FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind23CombinedBindingDocInputENtB5_7Merging5mergeB7_ +FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEEINtB5_9ResolvingINtNtB2T_3vec3VecB2P_EE7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2C_E7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEEINtB5_9ResolvingbE7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEEINtB5_9ResolvingdE7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEEINtB5_9ResolvingNtB20_13WhenNoBindingE7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode11CursorShapeEINtB5_9ResolvingB1a_E7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode13ModeHighlightEINtB5_9ResolvingB1a_E7resolveB7_ +FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionbEINtB5_9ResolvingbE7resolveB7_ +FN:286,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingIBz_B2C_EE7resolveB7_ +FN:286,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEEINtB5_9ResolvingIBz_NtNtCsbTJfyT4wEp0_4toml5value5ValueEE7resolveB7_ +FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEENtB5_7Merging8coalesceB7_ +FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FN:78,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2f_E7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingINtNtB2h_3vec3VecB2d_EE7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB20_E7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEINtB5_9ResolvingbE7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEINtB5_9ResolvingdE7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEINtB5_9ResolvingNtB1o_13WhenNoBindingE7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingB1m_E7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingB1m_E7resolveB7_ +FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolveB7_ +FN:51,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merge0B8_ +FN:52,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merges_0B8_ +FN:426,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB7_9ResolvingINtNtBR_3vec3VecBN_EE7resolve0B9_ +FN:426,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtNtB9_4bind7command12CommandInputEINtB7_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBP_7CommandEE7resolve0B9_ +FN:334,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE6unwrapB7_ +FN:334,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingE6unwrapB7_ +FN:97,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_7Merging8coalesceB7_ +FN:97,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_7Merging8coalesceB7_ +FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilbINtB5_9ResolvingbE7resolveB7_ +FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utildINtB5_9ResolvingdE7resolveB7_ +FN:313,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB2a_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ +FN:313,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB1v_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ +FN:325,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB1r_E7resolveB7_ +FN:325,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ +FN:392,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ +FN:392,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ +FN:414,_RNvXsp_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringENtNtCs7micvSKFzzu_4core7default7Default7defaultB7_ +FN:424,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingINtNtBP_3vec3VecBL_EE7resolveB7_ +FN:424,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtB5_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBN_7CommandEE7resolveB7_ +FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringINtB5_9ResolvingBy_E7resolveB7_ +FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode11CursorShapeINtB5_9ResolvingBy_E7resolveB7_ +FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode13ModeHighlightINtB5_9ResolvingBy_E7resolveB7_ +FNDA:0,_RINvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB6_8RequiredpE3mapppEB8_ +FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merge0B9_ +FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merges_0B9_ +FNDA:0,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merge0B6_ +FNDA:0,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merges_0B6_ +FNDA:0,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE2orB7_ +FNDA:0,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE6as_refB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging5mergeB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils2_0pEINtB5_8RequiredpENtB5_7Merging5mergeB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging5mergeB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging8coalesceB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils9_0pEINtB5_6SubsetpEINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecpEE4fromB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ +FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utilso_0pEINtNtCsktekB2AySAD_5alloc3vec3VecpEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_6PluralpEE4fromB7_ +FNDA:0,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging5merge +FNDA:0,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging8coalesce +FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging5merge +FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging8coalesce +FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging5merge +FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging8coalesce +FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging5merge +FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging8coalesce +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging5merge +FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging8coalesce +FNDA:8,_RNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueENtB4_7Merging5mergeB6_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_7Merging8coalesceB7_ +FNDA:12,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FNDA:10,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuelEEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEENtB5_7Merging5mergeB7_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_4bind10validation16BindingReferenceEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind15BindingDocInputENtB5_7Merging5mergeB7_ +FNDA:2,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind23CombinedBindingDocInputENtB5_7Merging5mergeB7_ +FNDA:2,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ +FNDA:1,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEEINtB5_9ResolvingINtNtB2T_3vec3VecB2P_EE7resolveB7_ +FNDA:58,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2C_E7resolveB7_ +FNDA:48,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEEINtB5_9ResolvingbE7resolveB7_ +FNDA:19,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEEINtB5_9ResolvingdE7resolveB7_ +FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEEINtB5_9ResolvingNtB20_13WhenNoBindingE7resolveB7_ +FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode11CursorShapeEINtB5_9ResolvingB1a_E7resolveB7_ +FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode13ModeHighlightEINtB5_9ResolvingB1a_E7resolveB7_ +FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionbEINtB5_9ResolvingbE7resolveB7_ +FNDA:21,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingIBz_B2C_EE7resolveB7_ +FNDA:13,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEEINtB5_9ResolvingIBz_NtNtCsbTJfyT4wEp0_4toml5value5ValueEE7resolveB7_ +FNDA:6,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEENtB5_7Merging8coalesceB7_ +FNDA:12,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ +FNDA:2,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ +FNDA:29,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2f_E7resolveB7_ +FNDA:22,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ +FNDA:47,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingINtNtB2h_3vec3VecB2d_EE7resolveB7_ +FNDA:35,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB20_E7resolveB7_ +FNDA:3,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEINtB5_9ResolvingbE7resolveB7_ +FNDA:0,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEINtB5_9ResolvingdE7resolveB7_ +FNDA:6,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEINtB5_9ResolvingNtB1o_13WhenNoBindingE7resolveB7_ +FNDA:4,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingB1m_E7resolveB7_ +FNDA:5,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingB1m_E7resolveB7_ +FNDA:13,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolveB7_ +FNDA:11,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merge0B8_ +FNDA:12,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merges_0B8_ +FNDA:13,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB7_9ResolvingINtNtBR_3vec3VecBN_EE7resolve0B9_ +FNDA:0,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtNtB9_4bind7command12CommandInputEINtB7_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBP_7CommandEE7resolve0B9_ +FNDA:3,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE6unwrapB7_ +FNDA:3,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingE6unwrapB7_ +FNDA:6,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_7Merging8coalesceB7_ +FNDA:6,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_7Merging8coalesceB7_ +FNDA:13,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilbINtB5_9ResolvingbE7resolveB7_ +FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utildINtB5_9ResolvingdE7resolveB7_ +FNDA:28,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB2a_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ +FNDA:20,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB1v_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ +FNDA:29,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB1r_E7resolveB7_ +FNDA:22,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ +FNDA:9,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ +FNDA:0,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ +FNDA:58,_RNvXsp_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringENtNtCs7micvSKFzzu_4core7default7Default7defaultB7_ +FNDA:46,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingINtNtBP_3vec3VecBL_EE7resolveB7_ +FNDA:0,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtB5_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBN_7CommandEE7resolveB7_ +FNDA:97,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringINtB5_9ResolvingBy_E7resolveB7_ +FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode11CursorShapeINtB5_9ResolvingBy_E7resolveB7_ +FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode13ModeHighlightINtB5_9ResolvingBy_E7resolveB7_ +FNF:44 +FNH:19 +DA:30,0 +DA:31,0 +DA:32,0 +DA:34,0 +DA:35,0 +DA:36,0 +DA:37,0 +DA:38,0 +DA:39,0 +DA:40,0 +DA:41,0 +DA:42,0 +DA:46,0 +DA:47,0 +DA:48,0 +DA:49,8 +DA:50,8 +DA:51,11 +DA:52,12 +DA:53,7 +DA:54,5 +DA:55,12 +DA:56,8 +DA:57,8 +DA:61,0 +DA:62,0 +DA:63,0 +DA:64,0 +DA:65,0 +DA:66,0 +DA:67,0 +DA:68,0 +DA:69,0 +DA:70,0 +DA:71,0 +DA:72,0 +DA:73,0 +DA:74,0 +DA:78,2 +DA:79,2 +DA:80,2 +DA:81,24 +DA:82,24 +DA:83,24 +DA:87,0 +DA:88,0 +DA:89,0 +DA:90,0 +DA:91,0 +DA:93,0 +DA:95,0 +DA:97,12 +DA:98,12 +DA:99,8 +DA:100,4 +DA:102,12 +DA:109,0 +DA:110,0 +DA:113,0 +DA:114,0 +DA:115,0 +DA:117,0 +DA:119,0 +DA:123,0 +DA:124,0 +DA:125,0 +DA:127,0 +DA:128,0 +DA:129,0 +DA:133,0 +DA:134,0 +DA:135,0 +DA:137,0 +DA:138,0 +DA:139,0 +DA:143,16 +DA:144,16 +DA:145,8 +DA:146,6 +DA:147,2 +DA:149,8 +DA:151,16 +DA:153,46 +DA:154,46 +DA:155,46 +DA:159,0 +DA:160,0 +DA:161,0 +DA:162,0 +DA:163,0 +DA:164,0 +DA:168,0 +DA:169,0 +DA:170,0 +DA:171,0 +DA:172,0 +DA:173,0 +DA:174,0 +DA:175,0 +DA:176,0 +DA:177,0 +DA:179,0 +DA:180,0 +DA:181,0 +DA:182,0 +DA:183,0 +DA:184,0 +DA:185,0 +DA:186,0 +DA:187,0 +DA:188,0 +DA:189,0 +DA:190,0 +DA:193,0 +DA:195,0 +DA:197,0 +DA:198,0 +DA:199,0 +DA:201,0 +DA:203,0 +DA:217,0 +DA:218,0 +DA:219,0 +DA:254,164 +DA:255,164 +DA:256,164 +DA:257,164 +DA:264,110 +DA:265,110 +DA:266,110 +DA:274,186 +DA:275,186 +DA:276,52 +DA:277,134 +DA:279,186 +DA:286,34 +DA:287,34 +DA:288,13 +DA:289,21 +DA:291,34 +DA:313,48 +DA:314,48 +DA:315,0 +DA:316,48 +DA:318,48 +DA:325,51 +DA:326,51 +DA:327,1 +DA:328,50 +DA:330,51 +DA:334,6 +DA:335,6 +DA:336,6 +DA:337,0 +DA:339,6 +DA:341,0 +DA:342,0 +DA:343,0 +DA:344,0 +DA:346,0 +DA:348,0 +DA:349,0 +DA:350,0 +DA:352,0 +DA:353,0 +DA:354,0 +DA:356,0 +DA:358,0 +DA:359,0 +DA:360,0 +DA:361,0 +DA:362,0 +DA:364,0 +DA:366,0 +DA:392,9 +DA:393,9 +DA:394,0 +DA:395,4 +DA:396,5 +DA:398,9 +DA:405,0 +DA:406,0 +DA:407,0 +DA:414,58 +DA:415,58 +DA:416,58 +DA:424,46 +DA:425,46 +DA:426,46 +DA:427,0 +DA:428,46 +BRF:0 +BRH:0 +LF:198 +LH:74 +end_of_record diff --git a/src/rust/parsing/coverage/parsing.profdata b/src/rust/parsing/coverage/parsing.profdata index b440dc25316972779e417501b15be2c79cb38ea2..ed8dff8605fdf68c1dbd85ca1c56fb02839fdce8 100644 GIT binary patch literal 1288744 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𝔖MPI9R@ zxIBuX{{W6_DpZFC!i5NWn?zCIY>AMo!%%L0VTikyNrm7BbWU0F=d~ZMm0Qgrmm;AG zVNI%6Y)QZI&|hx;ky`DcHUS8XlYthmlR8?c_?NhGAlvnvAcfSXX&$xs>v-3xBHkyf;-Dm|;=oQC96bt+hHJ2qzy7i9y$Kh&8siaa zh4g4P&?>Y@*w{Di&L94RXS_Rq0z80(ES`dAo+d=#w&6}pk+Vc?Ht z3gSWOrpeN~?r&E8YtvaB(5N2F-5;w&_PscAD&zszu|-9~=DQXd7A-gr~D}B z3vX(NQ2_=W>2IU>x16wVb*rth2$xm&YjIBRd%rSrVV?4ppzd{b28?K9E&=YyOJNm7 z60|1-_g)0#D}N^}IswKWCM^X$5qDj|D=ot1)kl9G{&~_R<>>j+My2~m9`cB90MD0ytUSTkg z?Tk&N9o{63qt%wk-Udt(_DNm2vQ5>qPmJy`_z|qXP>Bv=GR2oAuYsCiQ64Hnk_MAT zL+~Ty5vc$WDDXid#1}G3=1-X$>?d19yG=K!ecFZBTzJF$U0?Ahy7Q6SL}jsnGLr## ziqxlq{|)d-jP-8F?n@>`pjlp0QZDNg5T#RtO#%*1VId^^Bxg*B_yS&6Zzz%n&kp=3 zYZ75ehH*F6HTvsR4f1C)K=IWXv19Amt{%N2d^27QyZP}cwJ^y$`46@VziWb8iu~=+ z`r(Vl%xbiJ316-#rLgYlr)(AV+I+O5kvv6K+vox}^<_X^G4cEnUq(5pj9fZo#_ugQ zwtoZFuQq%pSMm`DWzJVuf9~y4c;2!{`9~_AR=iWDexDNz7O@%YbY#|kgolEnBS9Iu zNRXzYMJ1*>dfGO+Bl+)DgZR{(zgc;-TB*0lF{j#F)Hps8)b`>xQ%o6>f@`IM45ict-FSJeNZ^xm{qOvMIaJnm@i^{o<~-lmmyRJvFWT}uKoP&y{Ylm=$x5VRv?q?%3f&Tpe75NNS(P(6 z|0}|oMtZSbXABtRC^w_dffn5cjo!*J3Wn=E@sLspFv@%- z$jk?{i9xVx?wI)|O2>%Ts(`=z3SX1 zC6)UpJ)m1Y8mo{4FY)P4CM2r04zmRYl{Nq|{)i)!VjjX}%e52=f|v-IR5RWPzuEGo zB{G1zd74g-w9fv$>$j~l$WvlnDdN~Tpi_1EQmW(EA@wM|Vq)E3dTDbs3VxL+HJtJ0 zobc*5Lb$7DBy21@{e}NsA3_?tY2xDw=k=^^c&4zy-tJvaqgscAn+SUr#SGsP;A1ra5ZN?v!KDlX48&{( zMxB*T(0}Cp(;aM;zf}c3ME;5zObBEx6@Kg#lA>R=Ic9?W4<4%aCCkpd>N?w#sJ>!l zwi&pPMd(}k;**0j+HWp5*gEBcu5neI?!w{%cOJGh5DC~~8pð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

EEh&OKBwedE|b%XalEKf)nm9XEV z+->;z&u>~WvBRu56fnkX-K6~5uO9z+{)Ol<51TAoJdIPwLGTE`Hx_UJo)p!!nUsUh za*%?VT&$G5L)K+z#rw~x>uzY#ped${2u8zdQr#_gOv(Jmi#g?$LDki@X+hT}2^?~U zglLaE1IW3RBa8{dg6&Oim00XQe-QIH|#y9c8{e)P>p_2s1^NHLt$r`-1OBw$I=MRa65?P|};d zb|nu624NuzA_e`&puiH&T=pKdCAnS?)a~ACa;GWD#ed+i(00TtZaBOuEj$@xwk?=D*ygGnU*wV!2)0?a-&YQq(}5fSPs%41sy6y>`nVzN7y%0#zzIp4 zB3`ynkjNmym@APSw?Pmi%>krhro~YE*KB}uo{%ukHzciOHg2g0arFGEOrk~n=3iT! zysHbM;)QYVzb2v_8t#Lj@EHpCG0|K*FNK!LL0rcf*I#P>z*}QWTD2=i0&^8oCbL4| zma{(3%)DKAC{4p9WM#P@&$u*;B*BSsP{;=6MbML9>MJD(jld`*Cr%8ML%S8&W{@f~ zrP=pwV{f@O9Y^#X{-Ij(7@<|>Ul$0MwEr8y?Pv2R*pcC<+bcrU5zCh25=rXb?*e8*wV>nScF`pHCOf2ftBhxmQm6r%>`~3l#$X-xvA0s`(=rSP0W>_{MG-j&Dv4X z6l#W--#cJf`ULV1>}E()1Wc_u`E7JSO~SUT5r5_sl_WrDhd}5jjkmbRo6Y((==9|7 zDNRZ@evd0-ywTfKr=+*OdF`Y;Ee&9!pJ|KM2I+m07xp5Uv~KqV_l_e+UmgdCB;gULC*xC&)#_tG53oL>^_t zCPJ_JVmO88;@QFD1$}a*3P@V3C#h!jY<@%1d$$kfq(TWzWfR+ohIVm$9@LV!Xru}% zTP;q=9EOyml;V=oplD?ZoWvhFRidg4m7~F2ee@-p<`P-TcZUvLjzGi>txr-jz zg()Us!jx)o>WX=cg+Nj|h$*VIot;<+Kuz+~6%PAIu@Hvrq(|456CZJf_^S<9t}8RRXObVgVpoL7r%JO zk0V0h0QHEjE;o-`F!-afIGIDTd>T5w4w;df$+tD|+e2UCzC4 zIgle6xtCqCdpQ@}%K#%Ul4Nn8w##-u z*OT7}+upRz31OqCbS28k6#p+l8nNx~;G|9&MM(RB_`53Fn}klWE2iB!dPjFuaTQIQ zTC&k&5ZEO|m9i2Kc103U;ljhFzoy^6v;y_%rmA76U#o7P@t4SQCZS7B#+D3|Gbfq< zMmXJ3M~x&-)LVeIY9d|ypfS%!!=G5+X3iE_D|J5>J{4sgU1J;Xoch%C0Y7QR0p!mL zltpUAYp*A840qcQ#?lx?dMy@2OEN4dDmu>oQc?n0VVWe&zso6BN;15;oq7Or?Y)U3 zfO)lv3XrG)IVWF5@jsis^u(o~Jv>8>$>6bxR8#16-P#0)`_?`E(K8gjZqP`;0NR9x z3m~hV!5>5L#SZ00fFt7a02}P^M$w#J&EtmGwte^SXnsHGB?J4fMU02*UE2MvHeue1%< zuz9P8#sjja4yxII1er&@Avv++qz*CD(eAl-XKz2C;Uy|xiJ*_zV3MoP8ab&KlN;)e zrsS1=BXRsvC$A;W>4U`0a(6DEjn=D1!N9#b;I51aJuEfkV*mZoB%*uRjiMSc#*-dOr1X#R%4# zKbCH9IYwHeSuk=Qp8d@qw)G#fDVey0!gb~?%;p?k1JnX>buJLW#PJ&R3G6n5#8#->KR#~ph658G z)hoKm3S=1Bdlcb|h#?J!&>Y4I@OWJ2m{yJK5K8ecb@)kN3A)M_|f#3b0n1nJYdBJ zpgk7|$@4DWv|-E0Cz5ctqw@f%iK{%YdioZpd3U>i0TF$5B;ughH*dDw`1ak~_?#3W za1PWjZ5RQ%3+J;Y5WT_UK9IZ!3A7}s0xbZf4KXvt8cQg0)fbd_Q1#0A(a*QN4smuA zaSg&S+GZDy{mrl|@%QKJwLnVq?)TO}J$P z00^XB9ttzv0LH~$$ZiZf1)vXDXfKAKr1Z(Er%xkB7+#(7?VVk(xp(HE*`SpHuy4`H zLjMfO>bDg^c8yZ^5}@Co3eLT7A4^Dn8GHjeSd2;s7%16y&E`JxQSitGXhL0qTif7@ zr=Lm4Tsyq!^KCZGS*2NQ5S|Q#M@NyVrAIC+s#bdBru*bj3}pI?g%Zg_gW6h3p^&&e zWRVxhNtNKH7VR`{57Cl>kfS6~b(ADX(6G@VJ@CBg=ZfJE%GJt7&ej+qtLEL?QlGxP z&vTkNhaQ~6D{`|^QVJ3s<0N}I)Fk`L$=-9jiXc}45KD=K2H&(foxB)E+Mtm65Vg;+ z5X$CtSGfJ`;|%r`oKWmD8mAS-?9c+ki&kkt$6Fr_yq|*z!@|f5!WS9WHmjyVe48A5 z&uq;s$;z^y)fDGJXqX|C!R+FoOp+8T+jB|-km1ihQL769unew9cec))xvDSfUX8;C zC_DU2!pO{$5vGe0JLhV~D0|`wMRl4rMb*vC0={j-sBX&#ewf&=?SH%AD7^-wJWm)^ zlUU;ZYRu$0I-``!Q}wem<4K;K-{*}7BecjBC8Q2M8qE4-?gRZaG-uo!VVl_lzEVHgj=;h8Vf1eTI!|BI<|s+9 zaVO7rZ`#vwxg0IBsJzoMg)+y!^7P`>llp4L!E$NQ8xSGGF&u(EoM>;NPM5SdVx87R%m z^HfCkpnc=J`0Mn%P4hAGr(Qxnbi)gh)+F3obMl>oJ-V&bOTa(P0w_pwh0X{N{3&pg z{(<0MsGKZrnclaxoPeLN5=%I&7-4Kp_J^AWnfm`LI&hgIRP};NR7|3u^+f<18#_7Y z@xgyje}}JCnB{~>RQiGq!;TQxR`Sb5s0age4Cr6&casElj)X}>xM8X$RqGrC%Zz@4 zo}jfIG6siNSf(cE1Qw@s)4*?s-gIi`6)68yYcBIBF1|_d)XaT*QQw|VU`($Ie}-eC zozW;1n}=w1CFYJRwDijv2v#v^q$1@)3N{H}I`9wC0f_(fEfU`!Mr{C49%^-)QF9fZ zVx$or?348iUOD3`G|n>=<48z_j)mprpUu7HnJLRqKc}x8++G0{qn1o|QfOH@m2@+eAXf+x5cPI)8 z9O#fcT1>K9+7JJ7U-|aQ*+?_A?Qv=GibRYN%4W5G;)@MWeLaES3fTr=%Dar>6)+28 z$y%_p8R;z(O_!25Qn1gm%V-Z)9Y4Xixi56@({|G@$N&e&;HcRZ$6i)FZ{?-=FE2r4 z+whT-Oo9j+1RK9x>{0j4$v>f^b*KQS)-^q`~G57% zS|ma0i>oLAhG+2(%aAp(i>4zJs$&DlgeGC~+WD=!-#Pk%NG0KQIqun#X)%KNE{veo z&_qz5T6qOg$y`>m@KI;0|j(G1s0sXZ%y>VR-x*_NCL+?8Scz zFUqLy%3S(fm(O~2eUjf&HV8OF&ZRC*eIBrYkU-9>XF$_c7u1+__1>#-TB@ru%X?;B zw6!9A)_3~(!m_lBT0zkTwohP{8jum{vGjU)Vc&f+vTmv2!2TOQ>hk#w-z?t7pXkD` zgem^*Q8DO|s0xfZ+~eyRDlrKU#^3U_Ex0zekW&CNWTEl?3cTcGKi;nvTx= zXK@lh*8oRZ(YF zw3-(p{)eZP#c&2Y@H~_5*IvWN&Myl8JrsNE?Y~`rV*M_DCv2D1Esm^JCD4{+r>&v6 z1+HOQsRqg+5Jk+_4Gfd+G^Y_5hHq`&;qr?PU+(CH2VQMPX^ikl&3);|3Mximbwv0c zD2S|EhBwV6e4>$|n$#Fd0rIFuGf_e#jy`Uv;7BbECeTO;t$rRX9cpk#_X~gTCfkj% z;R`N@A0DZ>dewlP-9O&R?}tu_WfT72Ryu7o<&0>Ym4naoq&~YPi07Z2T%_6q4TNd& zgUzRY?$`Ef9h#hVQAbo8Z4$s4Do?d|LK}d`5rw=A`tL+8O+_^TIS7Ttv{{|whkg6r zXEB_jVWNW7YY^7e+vZyD6<2)f;9jDifT(eJY6=kWIM_C(tOg|u+5$*Hyvme}pBHD_wqiM#+JdqP zscLf;+^u?x!YCF#9ZIHilayGj@v9mqB|biDyT9GH$=7Vu?obj`r{%2roX50e&TSg0 z3hmAUrQV=@D82BfBA;W#^FdfG%p!GKdQuButh8kypg3fnaTHz z8adfx*VPN<5-D*InXw=YUr}*8*-j{2MH0 zNahSlQ;7$wxip7FM9N6{0iZ?|yP!rXvfNRJ)Nr?$geNllnZNjL!^1j;=UM8gC+D*e z!BI=m5NV$$7DN9$unMB=pLZE9F~2HPoil5D=e?zspXyBY?5o{Gl7?26MJz87Ef9lq z`-Amf)hEk0|MZmId9i+7&uLc7^E%^}*B|?G#GUc$af`iaNcee~{U0>lop=lOmkM_~ zhdE0j3{Dk<+MUx}_}4)pVXBAzv7=RZFb&Y}o?QOt)z zQ%^m`!NQsg_qF=;)kh!WJ2hl_M8q2@minC~)7b{p9^~Qi2)2MEoUF-e=BpL`ZYH26 zGMowfc~?~Btl+}uZ6(v-2m!zb9=*$fS3%lZ(lSIsEN%8TxW4VH9I^RxBf) z2KYA&$d69UnJ$G|=|Um{ zk#(&@`cC{ng5K!z^3AHz=Sb!m^iv7i5(5DCF{~ho;~n(tEY3T*zwsbE26|o`K4u*9 z3*|FRpKNHEg)I-lTs=`F=TLb_#XJx*4&V=H=Lqmriv&a0m0Je5j&ABH4K{F||l0hQX;zWFYKJICrP#7Ybp0#l6W}<4CC4Ohe5e)dE3~)*qj=^tp3q))-{?emHD?#nHzI%gbjU zXnbCigcJPE{rvimH@UQhgs4dSX;@b9ei@$cR!F*avy@v)iIf0wCO1vUAxB#DjV=As zhkIS~&Hnp4U^)#NV0cv#@{GU4m02G9@g3Kh#kJ4!U+5yQ3(bCs3I~mBF^C)t13+E{ zzDA$zwTexB%C)F1C7Pv9&-6UdV(vxDko~%=$b^$L2`knvzHoZORu3N3Op_!s(=Nw4 z`#}jQf=XsjhEVTN8tH{5u&^mCW{mp+?m5Id-NpHk7?jRc0j-EpsW#xzqa7CFb1T6Y z;mJWTs3f^cgK*S1sh>VittYZHI`Iq<=pCJi#v7Pg)~wJ z85A0=%v>^j>&?R&;1*R_fjR-tZN{4=4$=j{tp!QLEEe<6XTBi?k;#y9F~X|qNo^-D z7Sh*gxQiT6XCHzC);`Qj!qPG#m#T^J6ePBoHZQK{(Y&hqr@Pt=D5*iMRN)xhRD@+C zg^HQIZZ7eAiaewv34vN5*}KG(7K5)ceo={9wjmizbd1wT06^} z@${7L7xPCI`cVs$5U-A1e91>NDoJ>%X|3{!KTt=T{jl2;iVO{3BNwGh@zi6^{3sQ$X@!s_gM3dwV92hUz29hE%GEz2L z4NXH!gN*DP;MjsUrYyfdIR+P44y+(cD7^4$?B14c_xX)e^mrjFa7IHgbcLOLC0)j- z!@AS&A#~M?=0rZ~y*&5w93f6v5;egc_oE%|c2bftYK^3i#VhCNz5kM{h@^b5WTD?BY z@!`(@biPu1N>lv?5ojZ%zOjt{p>7Znk&^G(_5%Ix>;jf`UhG|b;s)1C$jC;3Wv|a_ ze&q6{vnFQqrQO7@%=yIz*~{1n#;v5OdIMAF|#J{d$& zz|R6*abZB~v&4;&~i0A6vR z4TP<;{yXo=d*7VBfZqyVh_kO^hsq~FNdXW$f@Lof4^xP6BHqCIdAYW(edBj)!x0x@ zf1J?yr3Ol<_7Y)>LUk)6^gy4l5TgE27Q$*0_0MMS*C~mKujJo_bU%&@!KsUM-x@!? zX0UY8y<7PE4u0ico3l|7LOBMrXY|URYRQ_RYzrwcAw@f7nxY-Jug1SaM~qs<+n2sk zfxA+DJSxQ8S#zrA$-_HmBXD3ZPE>ZJqb3t+R5YOBDECvr&8==rKibMNiTbgKkL`H7 zYrcPfj&l#@%;SLYimR-?;y`1Bk78%6ANuN;G2{3nq14Ngf%6TqI(R9MjU)-OlLSgE z+&QKG0Qlefl4e^}>WOi*lQ`UQgAW0MTP*ztP_+Z@Eq|1pN?GxNOjPxX<5)kcS^jb6 z=e=HB%17FZU#X}g-MVnCjj=3r>wM@&gv!v~4+Bl`k+ zj@eyY25AUngRfk1_~3@8lkUL{ekY0{z7V($F~aWhTc)+nZkjfP-w9s_aK#!xf>1R* zGHSaSoYihn;BzP*r+=>dv3`U9mIKjhl^Tb%yJp$Op?zXs8mc!SLf|M0;1c{U@aPu0 z{Gb+s{7V>0UJihluplL*#-4%?+}?FwkA#-bv_c|XWe^%S3Dwm{t~~z3pw?bomCjVD<7=yi&;NMZ793&{9{^sEXeMFL+Na*NwK(+vBFZZY6tN$& zsah8q+ChUTuOlK@2SFQcAHe?BSNmKiI_)jVtR8}L0cBl#KJW)|0{p7XXr?x-U zqfKKzWrZK9?aZWOL|kyW8lI%L#0@SX5tIy1z=K^e^{gU{nAAu8AsngameNZyrW%q% zis$2jq-`=V2^#dtYDX0A%Aj;}k*CD;Rnrm37nsR_WJP+$2%oMUQguh?=lag$w-kC3 zzMv8dHk59w0g_U3_Q8zwNT(=bOKrGG$e|&g7^~N!BKka$<-MEh|kF zs-!fS=Xh;Ww~HH&IhBnhM_?Wt8j`$$@OgFLS)H5Rz4--xD|{=mqC&k{Q-| zH*XU@51cv97_T_<&ok%!e)5WE-`U1*bm7EcpwvYcp$E0FT6Gn15}W{1z+4Z2uAKzgfSwYso8*Z; zd|%hO1+8!CfqL&8oT$M(57k`Mb$H)EA3RCIX32)G@duE)5V<0sJOj&RXSo@6X4+cJ z`CebP%S&rOpcWSDLcmS?;0@#NYj{bxZBTqT90$QrPS zqy8CAaJyh&5b2IX+^!U2Dv1QLPs$1Uy;K#};hGO-KKji4mu;5u^W|m;Dh@eZz3Yjt zdzYD!a^YiRr=9WG;G}}VgEo_O$g=a538(tfoo$y1en`xOdV9 zRr4o8M@5lHBP8-sh%z!TQu0Pq15zQO8Q?LZV_|mqLedZ_mE>baN}`sh6;~Shj7AU8 zYT!;WL)v%yODD@acs@nKpk0pi!R>4kj+7to+2MkmgJbzEWWK0lG~fVEfE?7~fEVm2 z##&-Je+_--Ef#n{0w28>(D*z#kR-%{H0!_2_@VskC2JAAv=je*yyE*fV!XD&Kll}A z5+nQ?J9WT`A4+bR#_xnJG3}uhJ<;i!)z$53L$@cTLP$!w2-T)EagibWoH}x4tJQCv zzYrG(_dU)Gr}S(2tM|9+@{$}P37t@?oZJ&hou&F-Xdg|Ae<`EU=x?fFjV5duJJ=zc z!5wj2DvFzgW106qIM{4En9J{sx!T?{S5r(%BfuwuVosxnyK+!+&6Qod(Z3nIc zFpFq@C`~VONvB49evRvwg-elGn4XGPJ`~NRw)^;fF~V=Ln`iA_{msBt{5wL)e=c&X z!jzRz7{~R_&K)N%1KeD1?bg=w3t7)6}cBXxHSTkc#R7NndMfQ-M zNvcA2qp?TPnodHHAT1Mfa@+x$y&qA}Nsu3PkbHd!3WVTSBW1<%U<=QSgQkinL4ViT5Av_vizE;d^Bo3HAwL0pmVw5*V_)prx_T#$RSqlg!QxnJ$~WH8 zZjbAh0{(t4er3}AbRAU&X{5w%Bq*TZuj>5R)YfSWw%?8CPjCMFs4A=d6#TXv^NJDv zh;R1tsjZ(6c!l5kCwE~2pg4m=6&OZT{#5p0oSEoQq}`CjT84XybG(p22zaRV+mCT@Eqc^SG^z@J5HyF?3kKZ;z%xeVYE z+OSv$NuMklviHV|hu7c^L+6K@Lrucp@v}eQ;M?0Cu?w^KBma1T0obmv4?Qj~1Tje( zNNEmHJR?cd&>Dk4y=x3grCn2w&v|lJep}q$M(Hj{%-XIf&SHd9~v(>y%Q=Nm*A=!os_56W^H_S zaogCD#LkGfN$v2wzYlTl>;(}>AIsjUCT^rcO@%|d=hdjO-Cc*P~dr7;PnbsNuX zx-9Njy|UaoI0ooOXFFG8?3`ZNxYrG4q=q+kk3IPOGtXW!8JB!1{=sL66Ko(f$Qs*a z*Ss!Py^57{uMiq%DvD-ERV=9InbTnQ)hAQi9K3dnc7xGkkUD3uGr)U`#Rq|xA|infPxughN$e^U%%UO-Gf(ukF@WF?4@1=M|Z*c;=Ku}{C#{5^%=%Dk<*pp zy{vMUo`!M5+~c9OjNcaskWsmcKwtgjzPVR@cKG7|pwe=J|JX9s^+x_0FUTn-;o=jg z{+IFdvSt1Gt#B!YIb)I3Lrs4(lE4;E9DBKL3s?rvPp-MdDW)=SYm`r zT0Fn^$92u7B8&!ZXzqni1DV-7VA$-06%~<3G@Fs)a8X4EQX`;E59r)n-6=?NCQ9(X zf&z*GL!6eqc~)3DX_qpzAc?f|3B|6D(9dD{x-xhC9Lu%n5y<3!G~&eVk2i1~_%)m$ zf~-?s;#jwF?!rM+pWx4hEDlZBCu$6ta86l)InU>D6j~-otYa?wmpdqdeE{6X$_tdw zOntJxK|XX%`^UfEvhyfT$jBg%5gJwe()7(KyL#dF2$>q3jwI+yCKieBG#&#Rotf-1 z0M`3_M3?H<-`R!b0)mmdztOt8?SrM&Z(=4vDC4D4oFXz9Y2rNY+H?dfQPpF+Jm2IyOEG8hQU2!5}NMW)aa`2%kRI4 zKY2fY@*h{})S5ReC@9`2Q1moitwRwQ7b*!9S2@wbBNdQ}7V1&wdN`QMrJ5SjCpmr4 zti$3c147Gm$MhiijVS-Xm5LFX?b-Isn4cYvclakmIR0M{Tch=pWYb~%3}I8r8n{&e zYC1ToX87Dkm+cM=KiP$*H+2x-wQtKZBE&L4SffR+-l_Zh}Q6no#{@|G01vT45@ zNS}5>H($u=wNdoy_P=y)wQ}H)j<~Fc42EJ7u59tct-Z4MKCxai7|@Ri%i5rBJl~g< zInd`EHv+PZ9l-)mF#*H@^^Zif(%~f-f5b*)LQD7fvF7@HCDuOVAMzJO>)>CKJpqZE z#ra-$&{vF~*XVslnesZ>n_{}Or{t@pLe-LnICZpakOH_0CZTzYt5O!WGe6LbKdNvf zaiZ03#zJ&XOyCvGp;kAW2o;&>{qri*t>sB2X30wWg^-WH|7By(&)a=yL6*svI7M(& zyGds+9{*zmj$r;PZaF}aCVn|uUcwc1{WD7|c0$Xop$5wt=a>91E#2@*i%HiYQSquJ zYRjxHs~@WQ^sR&Z*8TkYFBQn7-vn%3whUyikLRHQLjAhP+8m9j#a3NNBec_uUgP^} z+T#1QU6HY4gsU7M+3s}z@yZMQBMM`OoH(MG^==!g~cS4=HNryFs(JNv072 zud$MDH^}&5{_x0nY$C({sGryEs*1Kf3b(hNtebF1%OPu1qQZk3HWt(n<4KJMjcPDx zW4Hg%veKJ|&hK|6u8lGHS8K=lW8ND+>hga>EJAU8>Uu#T#vSejt=}rd2yGnQF8Se& zvD*qbc@%yl-cOQ;O4gx{Wy(+|WU;1t0_1$4u79nF)%T~?O=7AXreU5qVhH<4|41Sj zpj5(BRN@W%qlt+GStP7f8am`zq-F1|y6x4J4l+Qxx;_OZLz{KCKeeszV|QRlfSJn& zW|K4Uh}r`F9G`9+MX4$Y`gPXe`MFQsJYd5bD@IFSLGxTC!Ejh6q5YmOc3gWf>Af2{ z11STmpOemFg~$@5TKgde09TIr2)UlYsNHsOERHYr!0}0|3JCvd{o~;YFtsZT0H;9V zPm}^2wlku$26%db(*pT2W;ze2SR}~}*~t3@-h-g~#wAJJb1r?Q<(wt!aS@Ow@QQ1p zEJDYu$A9kQS^p#^+=TC9ihsg}8%0o&svWRvz@eb8+C&U4s`g}0?rkzpPY96Z)7vJeg{8$GIa5uRMk1(EpaEA2jt%6lMz1i0&~&zZCCxwhtT<^BhBC&^bxYd#QU zID63L2d$E^Pdfd(wl#`R_g50@0k8tdf8bLv$X0L=JW8@`@JNfKOIt{zs|#_Z5^<^c z6<5q$G3Lf^s}sL1|t8Az#vzCgM(EbkABEYhT+~3N2a;wF0gfT;JTo}%>Jw>qya`%d$_ZaBBH}>B7 z)-v0R!;oo@84Mc76xZUDCRs^cA3|(`Ui|sca37KDk=7!tq=&qqgJgi*qNT`PdyMg_js2b&SD(4@LHb$^!z3yvt)lchl`6qhuD~>mU&l7yD z+~>&zmQJKvRTn4%3LvdgCz)cY(gW9B^Y%k0A2;LZ5!Vy1s!7N%arD*`fs<_)U)8NA zztcrEc0%VURzI$v#}Cyb;D-hOjmI6>Go?%BQ0M!Pph&$NRXG0j`12;gmUUZE^AXuU zV#Q+E02ooo7~B&I2WFOKIlLvqpfc87lvCihk~W3$F7mJ4%3Bmday|6@E^$$K3aH*n z29pia+%1rb>nd}3yd*I(QuN8QbL^xpQ!kl;4)?vVRA~N#YEH&>29hcS~seIEZ{=Wy8R5Td$5Amjn9CP_eWL}scoJ| zA-~Cy5Y%ZuLucnaT@4%Pr(cpu5x#Y_P*pjw%n%AIIQG0hFYE2uCvpFWv2fk7R9I04 z%~~Q=(~;#|qfh(I9(UOdCy`+f$>UQqY(k6fy$b>bi!g_(7k`pE)4`*bn33)9#%HD! z4wmA)zI;GZh7$|^$anj}=|S?Rcvd#OL968XZEzA;r0vjOV1gl1i~>{8rCCzx23?z8C<5*hn6QDmP_47kjtZ<>VS& zs$dLQt3VU&U4|&2qd5cq_o#~JAUT^<(`5txLM?h229C9}?pe|0rmTIx!$T~*b92SpVjl5L)&Dm(bIdB|7`jXE1JoZ4*&0Df-?5N$me;eD2c-2lW zvBl~w?w>wgKaSt(#ji|XFmszI@~O+R8o@}y`O+^p(k4ji-kePqiR!Rcsao$~PumNER%a3@f`YSCb*a4w$^8Du@Yy`sKV!8}^= zBn=A!xTH8TBEPEw>!4m*hNoV+Xq4$DWbXDzS=ANil)UHSZ*Lqj_{1&z{x*JPtc^9V z8fis!Tz5qY0~NDETMxgZ#0QuNj9oX})HJcY%Z&9`@^9Oz`t@jEB6~Ei38MAzO0}7$0Ve*_@C$4ww}#&;j97-D<|^KQ-@VKjFo7o0Y~r@v&uqu;O$AHV}@Na zC=2(U-(VGDg#M29j|^^OwGY%;1!`<0XIV>2(tB4<7%ACY#BVNInB$y9azz{YZ4g&( z!1Qsua|1fZ!t@b|hbP^aw-!h9nT!atPB#LPTP~qq+>f;K!n9gL$|0kh-*%+(<`b2Oq z>}lRoXqdySqT0f41SFWaqO+y4eLV(U7k|U;DEM&e;}v-emoY{dctW`Brbl9OzSd!? zbFsD0prcLYW{dNLwOFy_ddeUlxt=0n;JO)0_qjbkVoA2b?^FUNaqTCPZ-*7pg@Cvd z9SC^dmI+=(8q!MXLplIaMj%^9qukj7UQdpjn#5M}Bs&%1TU=6@;|QCHGrtjm?P33s z2nqdk1$+^cPV4msm`1&Bw*b_9s#r#<(y5_d`;)J(AX4P!ziR4 z`+fx@$Z5%wWF#Q?8S|E+9VyKooP}(xuE)pKRS1+ZJN4E#r)A`q@>|NHl6@XckvJul z)e8W#jEhBrHOn&Y>4w$g;aqo~3t|BAP!3G5{Pp6)UvwPt`ZT#INjc7g4^A0&=Ik2} zf3)`cl9zRdeU8oTkeHmsQVtOk#B~nQ)U51%S0KmZ;i%8`l*}>0h}pA+p11UGbsbk) zLe`9U`HXm4KW@$?CCFtBi?VPwXJTCe9no8#2Ys0 z@EHWmqY@5e)2jL)>8OcvA^A@dbJm z0H||tNoG$NFrauq8ie#DM}Tx_;hExaq(Sj6v;-Rjnck()xCIBRBND@WOZw+7wgM&;uSjVcFYgs~@L*S&YqdzYr` z&X7}BXT`$kjV0Vx35ZT>xJ4R|r|(O?Jc%m(0mqTDU59s#!h9D^^FpNi*b{5ZC$wAJ z>>WO)e*DT)s*CBU^p7s>J|+xE_P3G@L01CQp8BZX^vj~!j0A9)g!XBNdOP?HAeo8n zL-NxP&6e`gTAjcICLYccuIDqwbyFPy{BCG=iL0XXbXHGJ z|3*A)!eRAJQDYtAf=+0)#WF@kC-_ydDo1~zcE5Vudc&^sreiEw?ZuO)8s#6geI9ws zB)Io{HQ?##%U_txzd2lYjV?7T608v4tfU!xAQ)f9;5-pV(_*D>Fn0j$3js$#5vlLo zo%wf%_?yjU6vkKZ;o((H2W3KeSrfK=)$YKArTmdD{7U>aBS=7mqey8yHUP|$QwY)J zfEeOs0j>p&&F&;n{-DSdD5(w!s!Rt5?Z85&OTde%FCUw~LD?nb(GP-_aAj_iO`l#I z){~`>G);v32njqmuA%^Zym*IY$eP$i(~i-4S?u`wZEo)jwI60DO z#+@~+WD*7sH7C%*&Rqe;$q;W3&~C8cfA;QwVdb1t87+~}i}(+zFX}ytG5I+DAil=W z;rE$@f~?s~zxm-=%QyU1=)(OUx5i7utnoMqZ4Z?->03tY?g5(YU zJ*2a`jcN!?{Ye28jrcj7mJDgYI1!#V>mMDzkC>hH%!iG=C@a*#ZzQF+#rDDRO1M&fbi{4Wukv8_nC_kY z*_2r*wnA1F5|Yt<5J_xl>h2jxJgvfdvhUw6hBQ0XTY~=)lsub6b6Pb>;EZPhNrH2h?t+&4PCUN&&X(W3IgJlZSvl(YL4`qcx-!p?Esz8GM!-g(X;D?sT2dM) z7#jVqguSfkhN{0WUVU(Y{giWhA6$9VB#@*yr5IuSo=z1POze>QGJjN=5-%6g{{ej) zIz76%Fs)l@W=~&7WkQBmk5FZvgy8_S4fbG|s}HO~#<)ZU&^T1Xtt{E(L{>Kxs4DT4 zMze^LD5bIhRn}>#V7ccb6rtrB-dg*BdRJFWg3Bl(F(a%Sl6pXkaLRj?JUurWzg%3-+{x9J#yv$y2`*h zYQqDkbz6%SeXaIJ^YvAYOqf({7Lq1-MYmHznkz^aB&84GU(kIT9Xnc3UiIWN$h?P; z!2F5>G6}c0NWOOI&<^jSD%OiXK~pZ+cr@%_C2l+`k@VyN5OLvv)g9K$bE@1wjx| zrjsG4;06Um6mTFeL}fYnpF2)o-b&Ll)c@!A|9eSZnw)#@x#ynwJ(a_!>`wlUKMAJ% zKW<7Y1G{HhJ~4LJcirytKAMO)dWwZ&J7ug0xByw3?=Y0dKqGDdg*^kbZ7w%z(Oejr zNv|?c>-r2-EwtD6r9s@=AU6XH zt0H#_N$a8b|2DKHzIxF7!pZ3TG&~5+3~3sFA~|#ESZC2P9h%O^K~Q=MXpI{86e#P} zM1bQbHyFobty}6+J>i~R71F`YiTmRDbQAeV1uFra45dl=y=6Wkpdg`~K<1|V+IAlXU;^yI)B?9h@~ zYIG`yqA1~UEPyL5M)!3qKyaZAhF{aFTcv#kFy!u;d2^F?Gf&sU+dqSEOVCvt!sQX< zvSv4#nCNzva92J7dd>l;R_47<_^ngsMLm|hizP=WCvbl;3khGV*hBLY`NbsMYZH=V z-<|$(Cw|;z4?X3WbJ1b7_M({F17|O;RJVSl)>uuIG6a{5y11fVq+WS>;V0NG?C@HH zcAqZfAHl67ymS7AXAwjn0&Z4i!*iF{Uq}C{Nw{zA%kQ~QZ5~&jbC;alMY)UlbHY2V z(f`_HMt0-tsR_)B5bc1Y3}#19uPXp8Z5gS_C~V9b0Y_vVWSM%x#L7!^izDCahG$h~ z8M>O(*a&kmsdWyg3Uq=0CJ=Z{i>`Ft0BT7_*jU~ZcX_YLoYvG=%y&S+w6gzLV?>2W zKeN_8_00Ww=J83JH!eWSQ+)@i*<)hm6K~D9>(>-*WRfxmW-5iicVhwNY~TvWkAnsZ zflIZ{H!O1)>Y%hF=v&<@uiEro=C0xUQ1wLCSI;#!7-~>Rc~Pd?E|`(g=#?)Kt9%4s9A>&!P_s~vYO26cH36L1REdG`BW;r5FY9Js zHgr(-1pEYRK#-}FeC=-OwW*52q~yBR73 zM!(Zw|7r+;X-`gA39GRA#1^txf-_d(&5&7g3~>p3x{&+~C^PW)0Pht88PV{9C(F@< zRlU#_vY2{z>Iu_ZKR95`$^Q9X{wQd7Sd*xla3XXHQps9^gCtPPNy25;1Jfitbao+&p*T925*aR1_mSO+PWR1ha}qsT^WV*bvDP!c5z{5k<)p+uf&G3mQbH?XN?p?9qUf9b*2u zoTW;-5#;QMr=Qlf$uDY(79b|e#6P@cD0_i9FMC}xNv6c zJ5M)S_)%N*s0B-xurLL|xfV@pR*Ad>R2}N*_9X!h7`%#MuM%QNuADa)=xV&Jd%p93 zjzA{QM)b7tWkfMz66UqOu}k{8(TnHvC$htgXqabOj#YTx%CT?<_%t+wJmdMh?)vEi z&uvAI@y`V91?`kUikrgM^7uupe*uy@48~m~&6RkNA+AgH4X9bCV*+eoZ18;-+*OnG zkXbhEr*%b-C(gk68R-`h!os!l=Qb?K|F}vsFAy93X)SUM*#*%O>I36Ga2c$J-q5@h9?PQSZ@NKjNUdadQvO zb4>7gHZHl+tMVYyT^Si5r_YftDdCeLZz}=3_1HuMcf_di2(C+nuw-r3b5A6VNgW6PC`*>9u6gtFHfl&O(c_&Ot1J(!{zl>(bWaE7~-e(@qy;(C@6N)-a9K z9)hX@HiI*caH|d^cQx{eRCJ4N6JTxTo5F$J(Nxk7i_K#SP?=#Vj9glpde5-CqN;RV&S-1`|sSf z)ba`n$N6?9^FHCC4+o^Cp7318Fr9jzTP4UaN4gtD1x5|H4S-g-arfpT|4*K8ad{f?N#m$qp66OuUG(9p@yiqVgJ3(M z&M>NIQ@wCOWP`^JMV>@P`OSbB4NpJLpT?DGJ(1+v9ieGh@DEM>BNpbS$fXOzRkkV0PTTZ^`Y>svz) zsCtu3!t*B@eLwb(x27QPRLa|=pU!KicQ&-u^qK8o({cxT4(Xg;;q}pG75=KCY;PgN zA#RQ+{^Y~@{hq^W(DwYxalC@R#yIrF{59S^cmVj@H4Z2*Ou`G52d@Ye=ruWP(hycbJg*QteIMGh1EUE&OwQF8qIcVO_hc+RJMmDTTcyVoP;lXzM zU+t$$B9=NCuc}dZ#aP~Sp16C&yq$x0jCwMV3vFbUMhL5C4!L#OO?^|Y*N7KtMV$Zi zGdcTARA*rT6M^Ai80P*LWSuov9W6XatJm(l{J>|O|C+;}C-RY&?91qd#+$A@N-}}(7;VU-}D>iHyZWcGp5;%0q`W8ewG=2#9V^Y4Re|&y|B7s8_QjSf8q{@o{=M9}-okQkK{Y_aK?S+HQgW7oGaM9I1<)0_GpU#rt%E>q)s<%`0GKmf9c-z7V`Dp^+EwpZ3J-2X&r^1QYD1M;>7$K^Ge@j1dd3`!NYGq@bs zd^sp#<`_EJZo(92lr9r0545VU(J_XwM}Yc4P>%rAm4Mr@a2Rmk zx6bDyT92>pf^1?WqTkr{X!h4XOo-{lKiGp4#p1xsb669fP)D7$1Tqz(DaZ?)5wI!j zDey+`GN+GT$M6>TZ=s=slU4q+@>#>v6iv~iEe>yGPx=``g2u2X-qQepvAI`qSwcxn za#?9f8Dvthp2mb>JrcP6q33`omK9fkav=Ggxo*({Sqp>c>oj-?pR*98tl)Rp-|{?X zYZ`>3;2p^Mw5C-RyAt|Ag>)?Zk_4C=&=T4|#5`z#7@O6*ihvmvmjm=836+etyz}JA zfny6$Q*v?j{4TCC;m8*~Fv!Pb^R8P@40~>;fN}cZW76NBYZ#{wPF?}J13o~IBcJBI z^XWFnrMqfkjR;{&<*ofLn(E(mh!Yn4pD{dGl z&J79Bq(mns2V5iU^{-IkJfU^m;BR~OjT;Wni;NnCCJ3q%fs@4lfd{Iduhj?_aWC9h+<&{Pf#jxIuG0C)rBT)e$Bt@fDW&q480#7PnK(ln2K+Z2c zm9hQZzC6eTjxK`H4S&>I9JruUy=!kqJ02&do)EsqiEUe(-RF)6+U)DW9|Rv&rji(U z$gqI#%In;+y;4&qy~^L0 zS%E70L{O0})?3+NQN{8@`7+n4Gz)b1u;T~JMt26~znDujHabKH8kPTW;Hrr70ZL&7?vfBWv6hjw4q4L1&PLva>3;>JY?A7zxLeAc(P(;EIL`23uY zs}4jsab$>5Ic`X_Ao0Q+Go)wXza>^YABfJFMZeca+8|1~#k2;ujyKmw8ISfJlD_1U zOr2@-%n)O%k?MVfh~@^uWiD$kKSiT zzPbek1}8w?k&kCC-Zm~Rb;1BW()`VzXCZ)mXP~V>%eWnW#5@GqWsqevlGrr z4>0OhflRDYe~$w*_WaQB#GCl@&G8@n_wnaV!Y6B=Y}ESOPu30LPta??%v8B*EYxkI zaA%OLj9G_B<$62=*yWeXRl=NM>4%kO?c^Rv~S9 z>h8<$&+lMDCPCOv+zecVPj`L2GB)<_o|pt5v;-`~LwZWY`wg)qQq%J3(IcQBZfB7g z<;~3{?!a6xZE!`kxWba?{EC78fnou8jA`m9Ff`OCFgOVtfJ#VCcpIYjq^P6irlskP zTunD4%|52a_<4p3=#&-_5c`73SdRAt5@4ihBSGp>CUAf27v5{~{?SOxt%~FyrILazPzW6|WCb=+ zX0|@F=j2V-Z}H$(ex;&BCgecIz-3ouJ^G=p{=!a!{&s>hp0JWF$LlI9f{GVlMl&Rf zl!8tu#_-;u0l=URhqtwO_+v{T+uey<$>~CRB7}pszm|_oxwtnf5whV+S&J==y?3Fr zUteH*f1Jdco5zBBR}Mc7e1?c~W|70FG5|UN?HonS2TG@CA5>iGgqCnQ(C4$1U#p>J zt0-X7zb2pee7NcE$%QxI?Sw`?j;bvPC{730MlIX^&P!K0`3H1ZA-ndVO`=Gwl5B$b z=Y|8R$L~vi-h8@Cd@J;+3JEF-aZ^mfSCy6@)2sR%jpFC6|2V6@s7zTXQX>YFR-!zNY?|`09EugA*}SAKrsna zpNd5^2*o-tJA-ox<-&j1Jt(x(MI#pDRdB>kiQIM0KzItzCOQvm8nw%EsPcmAulZ(o z#JBuW@J5|;iyU+%26V1)tws^;h=C%Iwdp09VakBiOf)69?tL;^vzVw_AAmiHh6Yi2 zP_qXcMJzGD2tGIRhQHJe)h=}}cKNRIHB(n%U6Y=#~m_NN%C7a4!WG zeDM9ZUD;QEb02c?6x=61%IE6vOy{aU>dkMD=L-3qY3Nu`8tPnWAXcFP3yEkE3_2c; zh70)N&LysIR$7MOJ%_3=j!2+P+4q&xiX&PioGRsyWXkC2Vv!=aipx{HDM{rnTV@JW z<~sAe64ZW@-5p8&931cr)(9MpG}DBr0|EJ{QEKJX{%D$2R{#n9PHEVC&7SKref}w= z{s5;5M=kX~?%M8n@!cvr0;VgEK^WqSQZHBU@H;@O(p&uy*RsUiqB-1uf;gdw7 zT@C>3A-;@UP?5kcT@dkm)S%K?F~}H3WjiL}=M!Il(Ad|pKC0sa{}Y~^fEg(@IRELo zV^Tc;JwswLK~NxxP0-DS2yGxL%pN}P?B83`>E-Lb#Jnc;Wr3Se*YRwBUtQ@?|DAj! zemU{&n#< zkE)JL;?_pDqDM>znxjS)R5S;dNQySdS3z`IfO{o(9Thqx@rAdjPx8DGdYw$dudR2i{CL6QwSN9cwtR?BggOIiz=xy~F}fdt ziX_A`f;A#P3_nK3@#wu#D_;2(MMQI+OX=XGbwKL*h?{K^em~J{)57gHOuDy#m7*Wk(Ls#}s>uCfx3J12p^N&dbT{#e8NPu<{1wA0I#t&5)9 zh1==cjz^?g9TLYN4aMAFdheZ1Ly~X2Bd}P3(mBlzpRBy1@daYf#8EnnmElh}il(z= zF+&1SKX-9*aZdotH{?*Fl&D(x>KGQgFNvJJ9~!m#OA5h!ubbF438!a%u=eWKTXvwPt7Ph0Sdc{FrMqYC z=d1?cK^L(iN&i@g>;bw*msjun>6X$x0asJ5au)(_4wDeE`}x1$@3Qx;+jX|#tfwVg zN=ki@k-YffPTg%^n@1v(pa&0$M9CE))ITXs`*g;=KE0UuIXC2pVi?RKivIMXl?3I2 zE@U(9Q&v~jsDJW;;uS3>I|lJJks0GZ@62IRP-`?O;{gAp$LBI+JU$}-)e|mR_wMpe zm&dh7|BAdVG}9ENR4CI_6X`a*MKDkZY$so?*cd@4z)H;Ku~3y}u~A`vRqHwg`AEzcM@?_d+XV2B(Itda9c>vupQ1NF<2 zL|RK>AAtJtW=GNPR}Uc}SI@#_VI$II5}MAss^5;sKX??=Sc6sY{yY&r*4%gGVA~)^ zS{cD`CrPwmH041NLT(W`69C!4-9XVaJ1Eoq`CBE6;xU|XQZ-V4qp1({FJ&nI0j0X+$liwWxdH}_9G*ze9kfuuR3 zyU`?E*55B+mObOfIyhM{mdaFmy&byd#g`*O!EpTQp~_lPUQq5NdLiX<9x zmvX8gsSNskf^QTS3rd<{p^DgPCi=QYKG=z#4@pk0d@;)DE0X+hFS~QB#cpr07*z)B zXR8Fzo6^1oR*B*BJEfs_SSLn4{m4bQ|E)OL>QOtSGG~GlT4hVa?ufZzRXqV>YLw(mPs}@# zn$Zfm3J;r6Ws*s_V%__HemdvyLzrPEFE(;GVTc+eO(s0YJpTC7-hB_8TV;Du1>a zrv>qC)FXc!_JDsM_8+J|C?A^+nGdasZ7^l#x!keD0QS>X*`TqRhnASe_$L}yQfz#5Ic6cV%-D4(-QdoTR+)02yC zUWCFy?YhFr%Co#C^XHhKc6o9J@khbJA*^aGV&y}-2~c@UXto)IRz#-i(|1Vv5V858 zbGs+U_QKaMI7jZCiKq66Dyk)ub=~fE>knNve&Tifql(2x)s9HkFzzsf{suMM8b_LR zrMXANxm?iVjcM~CvJdQmkBYJM4s#c}NzO{G?=dbFYvIU4A*m;s4b24z!dX(J5o5mk zVMOzm%FqsE%SKfz+pvBYy4H#pl?7&|0sWU^!dvw~jQqSz1m;ubZp_6j(TQZ#Q9CH{tj9p1Sp| zRGsw>NN>#@MJh33S>%d}K)5(m?ayKf(?Z#lw}Rvgmw^8H^rA_v-s<#5D_nl{%_1+q zwQ5?|orB6;`jH$=(KU=n@vuWQY3a=DVlmtnjLZWrQJaM}Vw^U6(Sv*L8MOt8zD3D0 z0T*+G5Zxy7#ak|Ivg}Kpg@o&-ikgQy8mqE1dAN1&;F6Kc-U-8#t4Z0^yw(-@PUDJv za}=~hXHgp;bWRU&pCeV8e7Pg`qlb=7!4)#PBBD=@zwz#Qdw)g;$27i9OaviXo(`w^ zOTnb)4i0M?{L5D2_0tB&@6NmUnsMKZ&uGHGDv^&ks9)pzXM2=6*Jl6o@%9V*eB6uw zL?j>CBmvd{q*v%vBPMsFDS{(`a`aREESknV+C@Knxoh>_N?ht<)kI`Ey6;{!C}yCu z`|}z)sODKWeO(RtkX{+cmjm!+ab!@woI>GL=F36-cMQ!5gA}3sAOj{&X~0lrR1M`| zBr+ldN1KH^e)-_&_j(?yfEcUMhSov`M3)sqbRNW8!Nzf|if{B_Up_%)D+dIDqs^a# zXMD3{(Vu!NPx|rJs4>=DeNzh^kZO&D>%vn4gVR&NCSd8Qu{=o`s-!${@Q511D{SEzS~-59X7#W*L+2-nvz*=e#AVLbSL-}b z24cvkpqN-wfT81?AZ9cK8+@b?JYkgCJxYHuXM8#NmuBOnJ~+wC4G(9}b%#1!k&@um z4@NpUhlFBQokT$1{4{~X(1IHj?q39__2gs?7}0B)V^4rOq!NjgMMtm9pQepXJ^IK0 zkE~L#CC^n>Y2vK?4L1JV>@lYfuLc4dq0{H1^L*a266(YSc7z&+-sH6%1ST|&g(3lc zPP^;JK1sJ7UA_$W@P6DxKFWKUlzFstYh`+rn?I3lVB%V=75socDeR~dRl5}YvjjB| zPysz9g>JA;rrg(gPW~0Q21<-usK~^ZNN$ACw`y=wy8^SXfycmzr?tPTB4GG35dfa}x7eA2!t?=nlr51Crgr{Q!8w@Z z*Vr#=4g&cT`2RqLrq8fKn0$f5nky+39!S0PNh2bfMttAKQr?s=IfmfW#q;<+ZXS;K zK92Z4j)WrpZqcm*fv&rZ9YU#HysjybmBt{tNR`9AuV$7$`gGivcqqr> zM)6Tz|8%?Ovw1z+4$aY7|4c@L=H8N_O2ydzkj(F)<*9xUA5eWuSdco*0c(rBV~%oz z+mkw*oe*$$=9D`DzyLf1&V5~4EPEtlJ5q^0A0!s3OwU}tV)_f+2jTNX{sCsihLgWX zam;KGi3hKJUKNlCd8yH<;E;j3%{TzNfLL}8S+}P5eslNA_x7woA!g^lgaR2yq)3&U{X zCaUN_GKScNH>PD3O~p`dFcJOzB~;qhr~rWLlH=8pegvT-zo+i#@W0c$e*FsxD={F< zBxKmv9{={4T{n1i*9Q?YYU5M0rn+5aK0lbp9K()mGK5^g=>|{S0Cxf|V?Ut36}m~_ zzS|MM{r*!YE09#9G~Wmzb6ux{*Y#PqV5APIRCfu({w24JIdEaIbERhjTM3S&ow(9i z$v0t2M}~C$leg_}J?El;ijDk<%ZnSHX@7d*{9A`TtLyJ!zv?Q_kIMCWY$MIp5@3q~ ze58$L=fF|mCMhLVG(&BoyHb(B^V$Bto-P}^uNy8IYIABTOhQ&0q28VIe6Q-q;Lu|l zg7w1c{X-YWE)8~m(&fOdJ>RLBtl?E7a$fDX?h8GojtV;?wbCd&MTK2Z>ROBsaJW2> z7~_J}hEiuSsd0M!fo89NzGwP{C_C^lB6zcU^&$jmcgyF8XS{U#MSMoG?n%96^w{bf za;(ELb3WJ;ArO)7%r0~nB(Q{ho=8Y089IL-rVG=6WCiN5CZDg#e*r%UYatGzd4X~Z zAbpk5Xf>f^Z6IXwvDh)FQ8rRcM8YZLeTUgkviwL6VELq}Pc>-}+YDC}UA#D|S5#Wp z-1mEX(`rm|DbVY_7N@3MUAX%d zXPfm)yT91sZwG&*l*lY|C1+%;B{wds!0Li~)L%q!SEynh!)!wO>!LY{8i;Vig33+~ zg1daZ(YqKGgF+3SA2a*VCQy^4Pzk&nbM49^`KUiq@3dG6URUxqHe zXSsaYUA6PaL(gPgdyZum1PegtJXkq$&4o7)3fw*;E;ib&yf#C;t)?9toX(sc;?t{dIg) z5BOX?sy|oLYvk7mp`hOQRpP7RumV| zB#hcU{`*V5?D&elrBU}NkOd%i{U6^J7q{!r$w&om5)va*;X9eybjJ;SE0^&{@-`B0 zRP7qJ(CdaRrY190**(Zs;&zWDm!K_$|AYJ)tnU!X0%DbZI65AZSN#dp@g~xw0w!s7 zTy_O>7I*D=)f>Oyblc!O`6y4|8yh7VhsP0AGDDzZaD zAs~XoMUb5k3-#6TZ-Pv^reA)$W$*WDgV!V)|3=rONhqE5#{0KqJv0}2O5P&47r;Zq zRy-u+jA$wH_(@U-04lo+a|nSJ$!zV<-t0x*)A~Jh+<)NlP`EMJPlxjGgjv&S1~dR- z1o;2WNOB2|XsfjB-IaH|n$%$x@*3_VvYgCoW$Qkf{Ml@w=~uc(i`)?*G(N^dyqG22 zcojW>5N*fm8TvXb*Bv_T*fG=>ZH5XWWbKQdVsM3#G^)Zv2iP#KDgG&G8xK#wRcemQ zqdAe4ZT@&uDx0_RVg4leL}H6st)7cB3`H;XI-^H0sLdt$8%HmlT9}X~LobcVpgyrU zMVSMts`7q0+R^f$mp_tEE|E5<;+}1DT9ckKxcwiIKUZ`NfLj@-r&PCj{mp*wzWzTf zbV=ca6aNT1>opM@fZGyn6@D3Lvi8r9_x5<|qNP~Kae{w6j<|w28oiGz zT)q1*@8j!-HPLfdFuWgf#zGjhfZ7u1iOo(NNh*cxDX_BA+=Ndc&=N}nEr7%20tWz1 zv`C;A6ex^MMjZU#m}VaaU|5q>E>|SfB;2tsF3!BU>#@OnZo#a83S&r8!?L}te(=2m zT^&Ca+Fkd_Z?EI=+m9>CN13kC>-rs=(&_GbZ|l${d&D%(#+KcuKZ9 z6t6JncaZY}Fdb7oBi)1hTfo8c$bsKh=G^sLK%>1)MFkQOA>3JYZSuSCJ+=F8{t1~3 z>NN=84hyeJK!<wD(-k8mi$iIQC60&AZ%o)nf!$Q*T99oc5Rs!W7#KCjl#siJYw`2w4T}Dou`#3cy zxo~<&e}pjM`phtQHmX?8$4y+BJ0W`rX zsW{h5T)1&@+>Fxjw-OaJ)tyivLf6YQ_eRT$O#S% z_&$#6XingR{2#ay5yB*U_tvNPul`oglXK2BIbaV(%swip6POB&OtcZ)80eh?<<$V& zST}8L((Y5=ch9QYgtf;(j7_}dgjx06ILvt=T5}7XrKM0SHxq ztA+`bjx7}=gIXT3rVjsM>Ds1IjbuI~*22q)w{? zUZiXe8JzuQM(i+jnoi>%VbYJJhwBOjY8zOg5i(#MP_|GP zeYnB8A`LglMrlrKrf4seEYN$xB;4aev3d{1XcOgt;?~PJ))z zDU%Zonz%Y`sVrnlU4;ZUgf!gF8SE@9qeW!jp(3POxjg{VaJ-TeimDNg_&$#KzItBx8ov);tH+w2t3Q9f zUgP}m_tbQ%U*qTgE2Dg7r?6jS6ba^?GC${~Bz>jMOMqV2};%yuFObg2##)C5+-D#Z+@UmXoz zA@?Zf#f`0pRy`f?f?bOf;G;Z`nQc-RC03>mImMqu@sSGyLY9#|guwo?{tC(@h){2t zpX-f=Ssiup?w=2DzQbaZe4URqh#6hKC6|hVkqsrU;jF3&b0QyGbpi#dyoM~ZJ)Dd{ zr6CW!|8x=k2#+GFAJT`vY7Afcc-5-+7a!PPn8f!s=-}~?eJKBHEO#XUmx0$YCXHsS z#XF(O*h@P+gU{yO_Zt5EeCi9219(<4Vj~xZTQJFYbt{^|!+Q5_&{#1+td)5mLLIJ}`C!E@8o4>r(#yJg;V*=^=oKB=aLYQm6`<-R? zY}nqHe>C`Tktnd=#kFxgtH(gsW8&6X5}#u0Ssd-nP9(AS98q+63kyMt5*>{;r6x8_ zEJ<6dMco{@|Kv83w$N%IHPrz}j?@{zf0$nv5OzuX7AR{0|2d(Q7}OZ`qw|MCb*6tyHlCc{mc+vbXr_a55TuPxsa6;lzm3VDYU zHJf&OhS`APXeE7~*|~?aeEwQI59Y$gVTQ^wP_S$4@N6DPeSf3}H0$|H$Oq>&q{NMM z`>?~aWnfT;XKL8QNc+>CTRd>Zo`6GG?c2bWH3{=)xt9!jde|!l^|7_8NFn%0(0dE$x37U4|LVWFOhNm!bhTWWeXE;&(W59-p@RSnzt z?tb4ibAuZK8D7R`Y1zr6%VypC?e|?Ya*D3%zeL#x2jISLVxOEwy<1TmDb%#{guB6E z>7#+jH#&JHVMUuopB`TP;<^IeT~9_14&5R}1uhSnWV~!UsV5Pnp|6#SB@d2#cS`J;_*>q)NDoSM?TJ}spV6_$Pvch%*5gxN2N0%YrSeC#(lmQeTEYe43Vc+IqIFT= zrYtiQeoE(m?OBulg%NLRHMU?69Q{*=rINYoVp0mrsP~C{S&f$)ur%;=rR00zx%GQm zkG&T61ygdg`?C6E@tZHLo9dsg!zZ-w72Om=mgZ=tX!D!7%@37lq>C>5pN^}d4o1HP zyo39;mW;ct%R^gnTJ3N?e3aRL%{uqQ`a2pPZ>`5}|If23+3D63ifGOSTXBS85;b{` z7|_B6mRELdX1@Uu4|d#HtYH|c>4%?@P)C@;93VLS%y5(N%DVVPt}iQZacSt~?rF;4 zAv+xELo|p{45Ps~TYSK=n;PuecFR6w*Dko4e3TdU)v6PJ6&@&?_=*mZ=Rdk9qeJR} zjhXEfY>c;4C2bgp-=1L8)h*a(5?-r{IrRKJ6Zc)IcUb@b-3=%e^-gHGYDczIm#MC=Xjt+>EDL5NUEN<=7twDIJD zttS`rxq zD0DsXH3)>%HdGxw-Kp(e)8hC8{2YxIvl~Y*762gu_&-QKBe4LA>yG@d+pLkpz|KlLslTtsuB%LvTO{zK5>eB;DL;eaR z9|^vb90?XRS5BMT5JW%GI4^3*OEKJ0_IF9(wkB!Ijugmb@&z(ea^O`Tnwnw(S&i_^ zfe(S4?i1SAOOjNq*^@2 z34*$49HM8Z$blT=bEn^!J+@%=hA2OET&6ASdNxXZtksV%{X>hS(EdWVpfj8OW!ad0 zb0%qoTh{Gp++lE&j&t~&M{Np$^#tQGQh2lQ^C5#0omSW9ClAd0v4 z-}K3WNl`I)(98JI$C1w@FrWn3vTnn%xhtE^8LydY?Gywk)C?}X;0l8Fa>H01n=}~Y z`sH}URL6T8r*sJ?5y!w>_&)+us)}8-#I|KdB7Z-Uk1UlYtg0$y+wNG&0zmxMk}`ij z$uT&b<+`-#(u_?gT-7}vkPefu)t;~;r{R$&-`7$Ce1w^j#&<4h+XE{J0hE|jcP?#S z7LGTMFMf#YEtV97fjJZ$0wdq7XIW}l5Y;QnduFec_G9-MQ|#{qAX?S&d3izJp7nM6 zj<5FZHlHs@@WIOP7jj2TMt%sEB6Fm3WbYE330HS9f(}au^Y7~Vq zB+d$uKrMy6r#ohh{vBBnx1LW!GsrW3CsSPd?C`xkmhjI6F(a@5pK#3_04QAmB0@UY zL0}%Zf=xhsyp-9N?2y%RTLBZ^3;E9#v?U%G*i(=9K7HuPK|65H)vDRbbKO?uSU+K! z_&%a^t4ux6Mh$w9#jsXn!07oy2$Ozb0-|XWXJ8>c8$Ya6g5Hkx~35q zQ6~Job)E~ad^2WY6@R2yz3?v`gA)K=@TwS+t(%mii&?5u#i7P9{V0J&18`JNAwu|I z)&R#9=AOHsAsNBzNV**p6)zvopWHW_3lHs~!aIvVSBB195~Co| zkf$#3uQNQ`0XvE8n8TbTDbFtd^K&l5!7Cn}B7LyiIWNjLu>)qesGWl9*SPm*Ys6#l z!K_xle>m!@SL68?M+P{EWD7Fh*1I0SBUI>y)_9N>1j%NqoNzxBIK)bi_G&e2=FMsM zqZ~7iRD9ef>x$0~WHhPZKmKKa2&xkq8U{*;VAxd1G3i-V>@4!Q%pRVATT5Z=5G~TG zOP+ac?CwteT5~cA`1oHRaL*%z9aUwnmVKvfMhB`=^qu2N@_ZdMa594eDFI5GuZmKdvTd|WLkT@HD%J$R-A$J`3IPA4YpYI4v1EZ1OBv2vNgfZ zRtW!talR&e6M*uXsZqj(AG{^njG%Sn{i4+wms2p(oalmj4hy8(6iPX8+m?EY+~9dJ zNA=_{g0oNwfke5}Xl*2IhgNK{W^jaieO1sr$(iS_|4!M~lYNd) zLVmFfc)m1i!LaDt*-V#XYA_Z|{e4u|20< zJs?N#JGm=yNyF7yx(Q1Gg+Js8RO544dO}}lOCcl~2YLs_KAPG3wf&<5sFB73;mbDd z((g?A_03+KV3}=*0aA-{hd?C{SRnCG+U6$qw%DS<6^}M;v=V>+Hr2A=s+ffRnXhdg zWL{D5vJM^4Q)(2yRt*k1fX#aR;OVE;M`TkWkP^h6;Ev6gvYmb!h3yYcd!4R4$;uF{ z-zG)DT}vVts%BH^#lgLR00CXUU6fOLe#Nf&V-s!;r12O*N0@|zyKil@a?wRM;$$luO}P$e|KaTa>uhJ)mJMUR7jKB<_{ zs7@g^0uC?dWp-bP8<9UCpyV%(pWARr(ui1ewx~^M6~_l6 z%_iZy-M{r&x@7yzo;oZa4)zMky^rx%6_+|I=>^OILtt-nZEc%cSAMbj;z0i_BrBZ9K`RD<=^+~exB3jr5Tg)n-z{Ac1?x46zGArlZB=YEGa+OQ}Ct8 zpeF&09v}-Ydt`2pxg%mAk-%=2ap>F0G6WCB9GtrT!FB&eb!QVTM})8QrfBbYGKQB{;M9aI+SdQVAmf;GqI zEwT0_{~`Z^7CjAL>sqkP-|9o0jT(#tr-QTk>Ewm28*aM(P5rrq0W%KALgknf#dPkd z^ZKZ4hI!j1GObwJ%){%$<{oC=-NOZ!x*zaVN+poX0Qv)c8p&bmI_CRk3*uX6;9OAj z;Ha5P)svr38+-eF?cEC33*)U?0&nUryfT@XeXs82LobtcBHxbZbwOb)R^ zT6N2WC$1mX7|Q_!WLEXmO~TJrt*@VRbIOVN{Lw@{68VIC}=m-a^#n* zCSyU*cTZMJqqr#DFX(wm2>9{4)!%qJvdg^PD5}(c6cjZ$e&tXPZG)>5&#uqieYTxDj7yHStUK{>ueXI#oOtY5l#Ay)&$T^}$*S(SfOo_@; z(pjU{t;9j7gev@{Ju!IMZ>A(S#{i1O+z>Utu~73%0f$Lid6eW#Ps}@#n$Zdc@{OE9 z+VK$wJX0p&=(-D5tv-ImlCSwA`Ah*To!?yGKz>e5Yek&ae62`;51OArw`{pa+8)+= zIRGSCo$u2D*N2btGMzX%ZC0Pph51SRiOhsyGq(um)s*k-Em%;35e z%>d~Io!x`9WYOv%ZviWV%?FK;>;UNGqOC#NUU_g{kGP>Hkf2^F{R-FW)b4geUw!kJ z;yIk09(<%06d{MOgihA5l_U$t@=jl*RNOTZ8qPUAL^%Y1Y7Bux35mHHW_eM9XdxNM zP{1#_^2>@xf=}*`pWnQ<@ZH24kquCN!m$aTf_lIyM+m0%joLkM{T=a7^N$2G$oa@d zQzTl20%~J%jL=DU-Bt6%X`0#&d@iDO@wGn9Blz!#h2Ciu|4RF+C0T3G!vPjax)kPx^%THf>9i5s$-Pef@F%m0C+ zhN@FnTsiieEi(}@H<(%agJFn=q(%!@6m#6fHRCA;*8=Gj&T}3_7JT4z4gh~>j57zy zCvu$um*__m4sOq#IlBX{+}4>$B^z-CO+vjrC2JG%JY)XkACReqU9Yn@4(Ax&RV7Ed z{tZqyi^l1ONHw^I^6J$;Rs3+ly$*L@&FYbxgEXfg92jz^Nk^n0cQW^D*}aexRRPsA z?%#i&ecA2p4!(g~iN{k-OoVXBp0~d$AJ{TuwGJ`oT}mmkg$-IjiZ+%#EIEBXXH^Zs zph}!DA8`{dS%2cn-bXsm{#VFmktXXZ86Z-`^@IV<3j1!-(abyiTrB#FS=h%v-n#Gr1VD>Z3w#?CE#G#Y62x}bY9 zd@iPUp*I_Pr0c|Yw_Q2>%~`vr3`5yCf&b&E!Dg9+rq!!=yfbF=>+zhQWj8gIHwFC2 zgeN$R{1Qs%OzrhhqLaXK)d4~g1Q`5fNDM`~UjUwCgQ>!QjKFiuae=y$BvQ~pwg&D- z7PQdf;lLxeb4g0+>&*&LbGwXh0_r`gJqdEoH#;@5vr}!iJq9XUyId;sD zwO5on29?vQ`_S8=n^O(P+(-p$ero2h$es(j=*9ofc}6NdCM4#BId!!^H?_O=F;|%- z$^(38j5j?g|L?AWtImR4z(-_;=Ie*`?pp8F#&|CWvqGIPzDb@3>@a}gL{YD`heQKo zX(_ndKhF`@dPU()J@5kl2>+p?s=m;&+jUQ_*mu{v|B`~8pn6;|iY#Wi_p%s6Zz#BT zv0xWEV|&UyIduhhZke^>ugt5zS(v7CI631IMM%%v4QLa98b*|HdR@XcK;Q44?l__n zK&iT)D+k_Oc18IwynMa?;bjfq!d-|rV3L;I_Kr`A&%AsLf8K+SEJcJVW+7~upg;wX z1UXbesf8pDuS$O3{C{N99W1Vto75d5YS zhe^1sdi;W%oR*F9bSR-Ny_&+PI))&b0PKFihJ-X+uz!Fs(E@w`bpoZHyfQ%Pgd4Vj z|J5JG!w26+LdV|_SS$Junb6j4-{0xEc-G&T^P#-k(5DuH6ZAs9(SR-KC2f29EPg)X zooQDs#0^Axl+?(tWV+g%I^1XL!pD1j#~;cH9l6hla-i>8WBGJkHftg>P@(CEPU29L zLI(ONSX028)l{SgYd1{v19&Hmveyos2EHCHd5X;i{g=3JPBhau;$h3cne7m>A#cRY zGK=_I@MA->roX-J_dr{{aq=oD{)J0cPiVLP>l+%KeE&Hoe;&z47QHW~OBQ+~DY0Ty z3h2F1a^i9OV}Y?q3PETi?YGO@-&E`yvJrRJ$OdaSJ8nj4#8-|C4S`hYBh04j93v>Z z@P9yE40^(dPb4iLbnZ~bqusi4QooMxBq3ebDi%%%Xn5_a_q=rEwFb{7^5?<4);|yy z4E0Nz-ZxP9lvtJR^W>1;H&T4T>sg+x=g|zs&Dbp7v>L%$F0bWiGhSVsJ-vfDe-Xea%8QtNaJ;+5IK9*3Z2b1V9mr4ujU)-wR zz{wKwEG{fAH@-FrS7%-I=kcpAZGn<%)=1C%H`rE03O)AY+xpE#R63 zS7R};ciIm+xVK{4o!PiVMwc8eQTw+2r(L|Hll3*eK#_brFR}AbCYp_yYfb<#msMbk zC?g)ZD>sKC~s~q$%X+RnOtB~qcc0k4~DX6g~YnJXrfVE!)MV{ z(w#AdoIg+&2xt{DEExlm)!bBbNG6LDXp%sLH z?nxkwApONbI*`RUK}oQfJM4RK>CM+ReHkffw4DDCA8?`S3z4(Gx?}WRSx2AIrNq!z z!LnqSf=7Q|v?PG`8&_Bwq|WI8hhQ3xRj!}aULdL%s+E+_>aTc%s3U)Wzu}KwI8PjL zwm8qoJ+^Njx_4FaE&PG3Sp&Pr`|a7)eft*oO)2$2`kTK99EyKC-!4T2VTWI~in2_-&4HNn8lX8-Z)@TJ`+Vp@P=W;~t* zrnRAKjuGoDEXj9f(*~&on6|2v9KdLIQAugl*I$;8pMKBBf&Dh}PML(xZKa`??Vde< zJSVjWA9>kDU7XNnGqQuEs660{8n!3;nU24Gv+jzEu0*}=ay8egRu^C5Dw~8Z-OAtn z)7oTg3V)clo`nW*EvK+)c_!T^{N5vs%ii`tp*@dhNKae*@iU-n)(2* zqCQ|G*m+Ta3?qSx%N+gnj99YQnE4xOCZYQ5l$ zL-b1!kV&Fu9xQ-SKnB{k>Gf_yT^bKPo_3R9+4IdU9UmC<)2si`2~hBVh$IsW>kg=p z*0fHHdJyY)4k85WDXHZjn;!XOG?x_eIiSjOIV9BUY81e`unV>{qF_KqJ!}0K7T4KI z-0qPi>}gBk{~&(`Uza99TMZv&(dc+M+x`TC%RmnaJRKklbZWI8c{ULMvjLW|{@EnpeKy{epvlP9jk@>};zuU8PnW>I-01yQ* zTl;&U7ao``9(Q3*ol2k?YlbT3RyZq^4Ss?#_aV2GIg<2UNVO2=oU`?LKr7&bJ;%^F z8nS||RT{8q;|ni#cGUVV3HGUvb2*pDN6^&I0`et^s8c}{OeH&oyisCp(bsE(Q;D33 z(j7;cGjEyw)?Jft8NNX`*Oc*w#wOxzK59Vpmc48FlSn@PGY*`fhO~C-vLk*A*@I)YvNyBc^!+mdm5UI1 zRNHTT@P>(9{;8RR)T_Pv8S6V^{j*2gXYbzmcV_cjb#|O(e(2mX+@S+BlZZL<=8)_} z8_m2ecly#Z-nM`HeQBUofpOJpT-H8Y+D$)vry7?&K)tPaTi`jki_aMc`5g3YdvN=lEz9O*>aGga{Av}PP#A*{-sY*BkkU+y!ZM#b zd*Oj)+iqUa7)dj-2~9%6shKTOw#2Sj!bz*-BZC@&_FGJb=y@%)k{osrE|I~kM=bm^ zEag~{w-m!#ypkVp*02}tE5Q5CghU^`Xibx z5J!YJ-8tNoheez~rRWY(2P9gtaEb@_Xvf6qAEtjjp-H>3c+}C+iJOCq8X@$V{mz90 zx?Js>$REjzN-_ipS_K4?du3S5O48%2sT4&F**Ddgnu zv<5l-Taij8(m4>)L(SP`p28ej9YT5`YSfZn9!~q_k}*|7a3-Gz3h)`hIFmkmw!AYe zeeVBsOYCTN5V$XOn{`CftW?n6;G(e;s%Y|R0r;5cO+)dTIJ`HRlp&s*m7sNk_#0K` z0o@S(j4Fg-`Gi&8U>(0YgJc9IscZy?HL+CDye&PT6^r|`zg;Y)0ME%cqeIK_EELWg;}ykZz}I6GylMDzz~FRW%&opL4? zmP#H-;_{Ak7bno@1N_aRechiQ(_w}MSqSd}^W%%TGDh&F7DTm-T$Oe{1Gnb6%+%O6lszz**H9%Qp=9tKr8w^JB2b zA;cHsT?Hs*m_FWGi8!Xjh3f^t>|H2!EQb6|Vwe>cI?M%s|Y{ikIdOG+YuYK@H{O~ef^L$ z_RC06gm8OS*V*-YPl~-+ha}*_k)fpw58uc6iO(<=V#XvcaKpTo4}HF};u`$PQSb>{V4n8Sz5z} z#NHR}{k(7rDjaw?kskGHq%1-hmUa4}=$qdEYyh7`WPmns&HmRrHfTBr8m+e0eA2p@ zEWSGBP{O6}(=>lVYXSEM_hVS~fghGX{Y=j+{y^T1a6!y;lKIRQn&|*KE`}{Zh^ZUCK(F}d*G^xx{PxY` z2av1>49OaC>f6TuTYK5d_vWFd8}QG`wj$Sd{}FKqSfFO$=kUH>*ps&5;zu?}5Zi`{YRw ziz2##*)3Th^yMIrNPH?RH%=N{W+V)yY7GH@9xT?VTgRNI0>EZ{uXN*^=t#sJk@q5} zdeyFP^9Q_^!5;Lqr!?ej%^;eadd(=a=Y zpwfAeCDt=al|C3|chi*?W2w!327VY(58)li(6!b9E64{Pp=fG(Ktl!YIU#KLuTgnX zPlk36DYl-)(cbJt5-`rO5*JDg^S+3|E*BCZi6wwS`{F-D4|{Ts`N7MgQhWsyqHw)qT3%BF6kGO$0%Lm?}bU|7>aE2LIa~RxXJ_R&9-< zhL5sP&#!*5FzT|?7k1?zmCY6^bN(Gk@#KzFmUBbHVIqC&67e9|HITk6L4ly3ud%VT zuVdx5`l?bbf1s|XzECiGq37k5A3dm}e}VQDhQ19EJS8fC)m7>%)VDVqwXeSI!rp7Q zq5idwOd6xH&!&NC$(Cp+-qqjwq_jD)X<6R6?yt4AxrdxpasSVyZ(yV}jKWmKpi$XEKt8S;jj8 z&9mOXN%Il;+$0pXb!R_u^pbgZ^5s$7*hX_;?iHN&KTuwf#`vph_ZStjHeM9bpCGfl(<;Cl!BR|gxzVKqbgDxo~%9?|bFhcnXjPt-j*xIyy z7C=QSCFo6X@jm@V&n|8D_Zowz%&VeQ=D3o!KTSIQV9!?)`6p!AO3ZH5Cc^dufJxPl zIRz{b9|Kv^`qUrmu9{q#fs{;jDoK$k@tyi+)2hcyQ?S>bg7>i(gMNIEAk&aT5BZyj zOas9^EBG^^>>K=NY5vA@AqA5_tPJ>L>5$Q|G2vHy82Ju z(sBNc#}aBQs!hItfIF4V8ppI0vkzQ%>AXggs0 zKxx_PyZ8eISB0f9lA2{atrSPf9Hl(43{i^TN?{l99QfLM;+4Z21BG8Na{_V1iQtG6 ziV*IYefhJ=cE^^*{E;kxh$#G5wS*M`QL7O6J`OV>bilchQcg*hn{FUOJ zdq?vJJ^0Adn9OI0JkOI&V?0GgWy}c$x$uzj3_clr2MSc-jRYHX&2Z9e^8Qkz_iiiA zed*e%$es~+Zy@n}RKG9p;^_649at6DB548tWTZSRk`|od5379ECY{gn*(itT)YQ*j zqna{Kadg`+9Pj#0M7_kHCn_gsoNY;aB@qz`=$SFS%8Fe8G7Al0pxS`+EMe%{B!z%| zF5MMekp;-OfkH75w?>6wVw`?u7-(#u4>6fq9vQ+k*B(8{2a_=0`3QV3SXB&$mFnh7Nj^TfkaOe6v zc3tOM822P!f*|$=-afwxI${**=Eiyi!92;o10aO}kX^?)MhN4wE{eF_Iex{n|Ask+ zgkluU&XSUvaoUib)oeR%&n;ixePqN0#LElb%s|X5q=}$RT9#9SMJr3XqY-?t32uJt zwbwr!{KfAmPEo$9DT)y8>Gs$~W4~zkzZ>{RWtyn;#KhnlT?y1y)bSghDW)PbKeeth zRb4vK9YM~CK>-JXg9`?M2l_NsgBWE03oDF46YTVWNc8<%e?QZwx=Y^UztyzZ_q4t4 zj}c40TQWk+=QQZaK&6P;ACd=Pd!a21VAS}%#li43u~GoJ#_p1MtTqZdCpMY)9-GFqVGg3>}#62gQ-?wP(hWXl+!(cI4Hsf$H1ltI3ILDdfaN@*-1Xlp$ z_0jI(jMFrZjxYhl`xaQCh&j0I4DP#n9Y1^F*0*P)ms@CsQ{$t2pG}^9^o<9;dSvVt zof)2gIWL#c00b{}TQdxhfVj7?=%oZjH0%k4ukuJi4I-k{EnhQ2cp&SOq{Y`P?7HRyd-J^TP`vDL}VLcqBSVB%3B<0G?T3>6|} zCn4Bl@Lcgm&h}F1p)NsBXLs(Q1{-#!kH5ST|4ua({B6Slois)tz!W<5a})y+!jx{g zKkfZ3xoR{2h;H9peS0hN zKVC`db1<#j%O!8s?|gG#J>u96W2~QPz=i;PPb6qV@ua(-+s_b(ex26+>wcTwc?wDC zjx_L5K9Y}Sjk^11}bG~g4G29eVrnw1vlTe;^6Qux8jx1l;cz2h?L7D&uDx4 zwPEp>_MOEa_2479*fQAq>1_{-WCc}D!nVTV1tCb)B&@LzgZ)O0mR6woo-OBC;?d#b zXP_L%YF*qNoT7S^r#!P;$zScRpW5wn{t<=XWaQ{(ds#rVv)U}^fWcxukQe6zT-NaB zKv%?(asCm@9p+w=Gq!s3)TK%NQ5nE0PxXk)hRYQp%wGS<2VV@GZ(qV6$xKa!^x4ht z;!Fo-n(X{j=)%BfVlfF!l9tizpm3KTc~YWu0D}9Ev^lSBve)d{FHUW^;N4!R>_zgK zQ)Q3swYI&Mjk-eIKEK>yi$HnO7F)DV(d{F6S|6^s$~}DC&_MfdBXC}m@Wku~4-CDw zd(WnvvlZ)};U}O!#QF@Ojx&9iU%_CdSHOA&sm)N`#lAw5nFY0|EZiSWfswhFLy7dE z&Xa_%3R$QM{$95q>r~5O2Z!XliwAgll`2h!g&hp#Owp@Qt&~n2dU$+g=l9p6$iopC z8Aq9+=e6CpF!RbG-8}jWEBizA*2N(86m*<3XrdTRnBk_Vks?}7Qg!y|Gm+brO zl`)_2M~aK(+-T%v<-y~_uH$G`$u~K-XPPt!UjYzeqOygHZm=6~794SXaKr;>5*F-v zH2;g_AOGsb9|iBH41HRoLTQ0|1Ly$+CTH{@KR8<{@M(C={_ROG>e69o)SsJZj^dWn@%V_Oyn;A*ptzs(o35Ly%Oos3_4Pw*zHNAA zymr#y4rV9WP~!tnCM1#qKY&(RR8j~H-w1XhftZQ{xQY8OYyaSbhhzW5l~;2Du6%^> zboKH+{~J`XGqEm2#DW{l4b@&|5l$`CSP-`udCi(aK~fEUA))FKpGOEw)<*LbXYh|GgbkzH5Pq2#f!K1quCgM~VWBXU zbn&Gu1!eCf21{Vgyv3}G2^{wrsq^x~cZubTAHz+>x(@Y-6eFces@wGc;^aYYOLJBhi7 z{pK>8J>V}Fqq(pE6z#gni=|l~_D|cmc+0;+M23brHH)Ng0*{o!vE%$4C|V33z2Uj_ zJ6?O^#uYK&bFPqCmb$@nxmeJXl3G2fPWqY3XU2|m&H5GaO%3We`&iU75&(D2w+=vOLs=+VOsE!cm?yR|iL10RtkR-Wpc(si(X*YOu^zYNN>$fPHwU?}*hj`p@2YCFy|B%7aVKc|12eT z_tMQr;SEMZtE@HS6!9({urFh#w0K3hcwC^;Rt-NS)Ad^Qbx)*rpJKyLDETOC{3M&A zy8;M)40u3~1$NRk*(d=2mFt8SZ2wY?oxY=BZ0!E^BO5Bwju;v0O#U5F4ic00D= z*$*7`i}(|q5wjggnP7N|j<&TtS$yzj1iHEq7zNf*Fb3j1kn=)pNWX^|-nX?_cw<$I z;p>svx2ee8%wI3y%MfTlshZBl^`EcUEDhS4#NUtPBQt=RE3~HR1OaqJOO`bEC}Nno zD`8WByITxcJLcsM;{vdIv-uC;fa_`!Hg|jAyL*y4Z$WpBk`$tJLrO=Dz#6PDV(d*cq3)EAmp2Suh<@OWoFP@sIgBT$r$dKMJPqoXc=}EQ3Wj z#13gzJ7iG)xI{=F8LtPrmNg;TO2;>QG_IM6<5;L}DxU{_r0fMnR^h z?a(3KsBYcU47r<+@)6v2%F}8_LHW0@pEaVn^{Y!Ysdf#tCBj%k=Gh80&^kqu1C%LU zJn`+B{xutXc*@lppu7MdotpVfbn#CYKCD>)u>9EugboeYvZ{}Lr6$g#NL16;n7=Jc z-dS`}^MK@P&ndb)FAW@p6`QzOm}zJr2BL)k=Yy#GTdiE)-9{x2QAUADKWJU=CC82P3XV zlem0U*rk}@v4*6aq>qqM};&6oyaUc}n(Rnx^`Wav@^1j3DX8^24 zQu(B*Pc>-}+YA>Rl>!{q3vLoV>2~KwwrkSctm2Pk=P|KJ$~aT#omwreuoj@S1cw9Z z>cDkXmwI;cZGcH&Po*e<5LjSeCYA=$CP>OlOiA{(OFjw3#B1 zJ(TCJl+#4u@L2zky)S`_s`?&(1DdU-wpeP5OKC32n}K0aN*M$}L=jw2v2lO_Mh6CG z1_VSa%QQ9HvlO$^GE=iG%TlwnQcKG+D-|m>t<*BD)N=cuyPWrC-ZBiR)c5!KfBNL* zEi-fOx#ymH_7iU}_CaNR8WzXmiGod=xAc)3g<6t9PaxbllK6474~+CTZ+_z7x-XC7 zyf)~}>$_naCJaa!b~v6t@5x8DbhOBa_76}S4(whCg&=efGL(M}auWOUhCOF^%HJzo zXum~J6p*Mck*>moJ+q!V)2j2PaX0gi`q5SG+m8_pGk8_O4UGSWPJSdb%mf9%_$Tz@ zQZGb>Jg8|3Y1&p3amsqgIp%?UUEUR!#6M})y+d~+q8c&0XU9`hubR}}h37(&y!fo! z4XKTnN^H+Le$ zMI0U+5aKZ5r+0H-nEK?C4PH<|To3k8vgLK$u8Jb?G2p7NqyG0(i`177+`9M;bQuH? z4CCyqD8}5iPyY0 zQH63!B%ud!TEJ65d&M!Sl!Q3q9dZCk3{Z7mE33`ANpU(Lti>n(NWXek^+(0|U?zx{ZX?f#tz)Yte2 zhYD%=V7G?%^!GmYC9adB%by6|E7ZAU~>=yCViHibYUCfXe$V`pp#_5rtBbFFglYm~eR3yIX&- zd@_Et1|*qYt8NQ$cA7~oz(ux5wD~s^8Z@MLLfn0xcFO{6)KaM~dgd@YopB(h?sXNsM5yGm`KCIiy!s2p+ z(!;bkq9mI7@@v}FBHaNIii{g-vkNdRIPxIVkNivj4pP{5VSL(G`!5=ID^jPUkv5_Y z!qIp1HyzqyS@I)=5{@LXxja}T#?bm2+fHgXaUQR5%CfahUr@1#wtR-Hq?-2 zMTgl3Lo+`}ogGX8Jzhy?oBJ1TYxwlw!51S*AXy_};Ps!w)<4~&LG#tv|#`qoQ2cfakXjR5L^&9}$yb!e6s45#wI4K7!Up8JC3l zJ2@={7(eJ-p=41`qTT-ui@JA{~TxeJDxZ3XT@j4a1UAuMDL z$&Zg0}nlI%S&r<0=W%F>ENiqjOr5C>sYsOi+iouJ@E_vhP+-Nv9kI~WJ?AK zN@2xDLt{d)&cRYo$d|A$s+k2a&=uGjNz9=qKRw&kEJFGzC^vz+wt=GcQsQyjz2{XFGJ9yB!Ik zEm8s><$0bScJ`%LzgxU#nQESr?L>py%hoO+@(^mA6-m}Ei1;LZnFtOkA^4{``jzt{ zgisD&O_LnKCS2ebpA{DvpXD75)-K>(SmO-mtf!oX3uh~)G+g}j>TZ2hb0#PB*t#f1 zG|B=}A00V9FA#U}?B++)_B|%WoOHmmK!N|W6_%R|KfZYPL=JQZ{v1rrwYTPS%Bn>k z99aRtG_0YH{g?H_AunlAY*24aoejWHMwlGxCX;`U6u23*JSnABD3$=sgHTRy?MlRv zP>DE=iWe|tYOD{8`Gw>>U3)PqjC_Hl!YF6o&FNY3{rA6)P}367IC{`(5kM481Bi?y z-WP;Bknyt1N!&^vsDMQ|kUvVc_v}9otm`zr%|Rsfo(L5mc0=83Mz#{8A) zOs}t2vKC+#63wWPRTC4VZIj3{2D(KVA*p39?g=8LAVE-1kP;T+evXZ6P*@Rz$XAXy zZF#;8T7L4x(u~xnH7#V4wyv_gFrFIa&2bll&PJxm+U&4`4cf+_alKwm-u=s)7A<&zuAQJRHWRC9m}D2=-(PDEuT8+Z zOrK;aCs?DBRcXq2is7i-e;1v6@xz!x+dXfnjx(~z7(W!#+hy;Y0!BG+960nz|Dfn% z4>bDqIfyaAROs}QbV}&m>2T!|9%8Z?BU9PUL~^f=3H&waN{Rq}3*_o!4MQ7SWQu*O z5h^5;093DNVvEir?)loNnHwsU{Dshn!)i)a^zh;zuaC92nxkw>HZL2uI=S_7JYsNE zF1bOtc=qI(pPX6ua}s~_KIhWRUCvZ86>sDDmsI@F?b7aXLM@o`_r|1)i_+WNIgo#U zCj_CMM!iF)wm;vZh7TyLwE`OT>wCU6fT{Z!DFjF5i%N@-^7()L8rKiY?cjOegaeKv z&O;VTE*<{n@=b3iuEDr&`RpSSB9*}ia|&h>3<$9@7lS9X6l!OJy*V1g4;6)Il&H31*ta%!BUJel$Q^$SUc{e(k^%NH~gSHm&k`0>Kv8pT@&wGI+TFZR4GjMqH;5_ zB^s&eH6A^vxeKZRlDz(t%##djt?i8PF?NzHrICU5h3z;g34_ z0b2iZA!#SVYfMXFRek~Vk;M26K0R*@CKWxk+aNSqIqudk-ha5*%{heMbn8pm)zSOt z*{Va57evb?zon^m10+`C5P#Lzlo6WhYZ^pUU-(zugvT0LKmuiTBB7LKX_-Eo4*%oi z17V(z_Wn!si8dmgU=^5dU5$k%r+>Ob49N`%ZYb2J>SjBW?|tp3Dc@rNu^&|fbGN{v z1XcbaGZyB-+Y6I`q8t0hm45i=l9_mnN(D0bBFM{gZOd0jx7w9GxVOgg@MOYZM@nE( z32;6_Wlk}I>~gR~<~j3wTsFAfq=Kd?2uOxb{8gCH{N#cs#U*b)i0d4Bv$;FbMjA3L;RegFc{jc+L*}uATkJyv2x`!~FMg{HtxeQDL0iTptaKJo*lj+rb3C81f5{YwAxY%Z4AGE9}&g87=t85o4?TBiN_ z=b-70dz}yF%h{KP39UXjDc6KTRHTeh-GQZwaq|)Z9=2Q%qbH3PhaCjHm9f$eL==dT zfyH)!oq}UL0=@{_mf=omgXrfY(vd;9e&?Aa>#+7a>bp7vz{ytztcT351R>balmzlt zBGU`(&VDqsh%_r1XqRmD5Se-o)fo)JP2-k){Lypke#C&EfPI5O6~Uu214;{N=iNln z20bk3hXmmDyzR`&%U3nX!qreF-^i=c=H%jozg_ZS*QtD+{Nc-_tea3uP+1Yuf@%L} z%EKWyIL_m-moo|@pHv0)P-%h(uYHAbN_He!TF_^~)~( z0S^YmG>!^jC7ZcHXt(mSY1Qw?yxL8Td9a!@`~}53i88T})K4OhM}Ws=@TDn>kG#3L zFJcNyVIU0hs&^RP`;`wSoie|n`fX;U%Jk;bLtCXGNEIStxD}jHM-cyeu(lXr))I}> zm@f6qhBk@O{352*>4o||z_=JPfEK_w7EqEBZmo118fM@0S#O*)TD_H%4ih@ge)^HA zv!8hr$s>T&**sJ>8oB2W9U^36 zvMW+jic->i&SIOzO9E#hVvES^;O8*XKw4-SPip&zqTrfr2{E+vNr6K%q~`498yD_6 zv`s1|hYcH*t7{Ot47WG=*!=inGk;XTN3!`t*i2EBg^^-s^pB}wuNEC&?cH?=|CYvl z#LdbtrR{tfzoE<%!uRm=c#T^zOo-?{I_cTokx$R#j{>N&o*g4Gkif##Uy{q>r}>J7 z4iEI$sGEWi(Y;yA@TE_`qpd@cP+;J5nmPTDP)giU`6YG_HG>mZ8ud!`CU?lP0&$a$ zoQn2-)N@S8mDK*X4g6)wtrqbxR>P6E|d*Qc)gde4IqW;|7I z<`Ce>FQoy|7}fIR8BgEu8f(dxwdG!+i}AW?hhW5j(~HVGQSk*(A~RtWFg&szR9>Sb zqgv0OO1ItdUihuUaDCR{AAGjbTu&B^kJ)(RS3mIk^6KCjj$YN!G%O&T7@MqSu~j>d z2Rj4{Do=LDm;vl(bmR;%3hIdXySfsfqtww&pYPc7>PJ;b8#p3fB%)B@D@=%9S(x+I zp^v}CsLKxg4RSC%A|Z!)y0IsaSfrKs2$de4_o=ZPpKw!^vXAbG>wvHO=1u@W9;4HF%7zjKBlGOYHr6G+`*<;0}0APWj*NCJ{nK_FBlseIFY6h+yky@sDwVGzTVWsPaV9Z2Sas2wJRjjoXy& zeZSnWJi576V~UK7b!$h1&4(1U_L#jnc9$ItXwbvnRsz{j9^k1SM~9Xhx4!P0wGb(y z72=nVxWQ9erX@7)va2wizlgFZ&x80s6%kcqR7@?lJzE_uxh@j27X7P0(J-dSL{%6Q zt^kg>KzJQ4^xL^{&Z3oT2QJm1j{4pJ(8-t>6}fK8balT?VDT2aoH?M}(MFJUQ&Riw z{QB64A!i=l92)W^q>XuiEs!BU$iW)}iJEaa5I^h{&qJ#f&CM53%#2NyIG&l4$gfY9 ze~T;lf_|e~VkiZM*yxS8c(`g|Li)R-?EM;)Yf<4$CX_0lwV zT5@TQWoR1EmA$}Cjup~HX*8D~%^=2s2_Bvi5!oCGjz)KpylN_oNQf7Lw%Ub9(=X*r<`4H;c2lI=f+2zVtUKvbMqgHJB+G;{{&OLFcu&iWPgFs3__7m0gXWzG;Y?Kce564)5*kQ;!J3ye%>-h z^{Xyxvm7(jaE1JTUTxV$D=U*5*osMX&|A``4Ct_`)r+af_L9-};K;|CMk50Cf-4#b zL%RPK-o+6<8W&t%P%2EH=lVOu1Zz)P#Rz+DprHc-|HGP2oO2<9i!c$7F;;4LvK8Sk)o#7f@S z#j|h6i$C|f>QOw#P*q3FsbFe(@4-)eZ)c*e5vV$%t`Uq|5Gx1vY~>hbsI-3Dre;buS8G-N1TX3$UOON$5povK0TkmAQM47 z7^;-Ihptb+2u79?$i}IgycH%4pMBj$6+4@J`i|x-v8sd)sk5V>i)CtwD=OPv=EyZ! z-DPayObGyNoXf}LG?vn(Aet`Bchft=akt=z%Zv*= z{N%uWQ|_M9)WIM0GMD^2dR@(Hxe}n_Srd4 z6lVYQ`Tl=tsuwQ$&lr#@Y|M3*f?2lCc*@@Saj!$8C#CnJ8Dz~UA!Vx^MWr@)E8pR{ zyL$evcu;{Gn2zak&iROTXaA7rI!Vm?ea)8)U4gr8ch z8*nwqF5(!b7a?W6k|0w}c1Y4)VUY{zys(r-pqK#~7>%L)s_EC>K{;>bqJ)7XA`wTK z73Oy@Xny%H*T_#aR+E*Csheke;HUu`Lk=cacb*S}!rv%6k69scGI`~w}N8IvU<-q#=;k4y); zJYc0Hw(B&w6_d_++$JLmsAdaFIw_JwuS1HxMYc$OC-nV|`!GTBn^=t%wq}P{RQ6A? zq#=Iv6g-3AJh^vA>+*iRd+}Fg3{hrN8x2{CJOi&uG-VG;0to7L2{pA5nhTv%YGbW9 zo&Hi#ixC#w3G9Fb+zJdv`L=7Ptshz3;-(^81ynPTdXY*E!l>a--q-c9hMl4{>C{f? zG>FdyooJ>wug?VSw?uMH*XO*(HC@8~v*g`8V<3$59E6K^QY` z=f{p6Hzs57Y!ZKk1@Ow=prA@S=-=RvhLY=EcTr3>_{2$PpwX1uLc@4BaZ=@4@wUTb zjDRKqaKNyD0GAt*yWkWZy8pH|-UYo5;}LNS0;@ABpCgJ5f~UK9Q~ciSUo-e8I|R%r zl+LHBI|f+avx6Z!pb+eYveexEt1G4=6{C!aFv~!V?cU_7*?re^)Q*!9dr@I2 zcs8c0xfMH~#i$`pUqJ@R7fkL&3X;k>pKA`LIxSTR^HOhGDZT z!~_;21`6(!hR<}nX{`@ui$tTIZQ1brMLSote>R0b+7Pe=Bs-hH7nG=!mLQfW#Hj}8 zWlvF~7kBSz@!>W6t5Lf~V9;2F)_i=9OM=()z+Ka%IO~ue<+)j(Hjjj;)z%+#mi-muz0fZi&zd^`K~<7$>O_0t~Cr?t}C- z5-i~KLHPbpFTV0}voW7bz2h(s80l6f%<;n=%kMkXvl6QeCHWDi96M60T?{sF(pwGu zP?$j;MbaQyf(QKTbF|7E|G|9=4_}Js0D^=2M>!(cIO6+Z!o==>cAjwhtN2g(qW}RS zlZG-8EQclxak*c`QUgn|P&tWP0*zqrP^O5kx$zP9eA7Ak~8m9#PP_lgarA1&?8#aQi~c*FBy5idVkIs;`6J@CSWCuWx%v@RahUOSxs z94g?7v0*gx4xhw zn0M7YE=(n{pm9k?iwBArLu9O6I_z8`l%77hqv)d*3D?^-cVVs4F*LV^2^4)AG#!}$ zk<%no!9=={^tXLIa?gSnUcB^fBr$zuXHLsMr~R^Qp|4B}MDn8{m`4al1+|jL4)K#t z!!QEgLid}4X5>GrtL?;qY0mQw~s4a4v=$K&6*JqhVZ(dT- zX@}J9z8%LX4)T7OyYuzLS9d;`m%tzSZERqK)Gnd!K4szY;a-5xuYiu3-X`_6c~rnP zf0ZPDyQ%RI)Zsn+M{rbvGq?M&$>9Vq;YU?R019*%s=_?vH6=fJwBN~@?RZN z*IOsSAaHeb0jI3Y>nrp{X23t8r1Sarmw*JcF3sos_TG^$QYv*4&VY}&{pOF0dF!)H zf3_XT@Au>*TCC3NG_YSCz}Noq2V12*_v!se{>}OC;-I|7`v|u|c&U4J`*Cv`9vQ_S z$!r6}ULCNbi$OgCW2-LSL#FryYcE@Q|JDPpvFvYvL?d-aL16hP!@RKjBeR>jpE4n< zE8rW1Vw(V^A@J3Z3lu|~y3nV(*t2Qb@dvVBe&es(_|Kx`rhq2o%O*N+B5TxnEZsiW z-2TOlRx6ZOhNgEPXia`o$i%) zb^mGdHJ9@j1FT5cYfRq_MUGEsNGpdEaBY`YS|RWjCypyLE#jyoo_AVy{<*#V^*-n(@MB9-4Gt~h zjRdQPBMLeq`n+D7QKSb7$-<$h3S=7)yC*~gkUAWV?z(;BjF&I{6qgxCB`D#-yR+YT zKf23j7eB}!$;UGZ0UblddQD(R3Idao%xSI?kKGj-CDUA!C{@ShG|5I~?d#ufIokHf zPt#Y-x-;<%p597NgK|pmj(cE0%Cz{FC~x>-7bZmdO^Q20~HU! z}j;G=xB# zi5##N5KENtvo zv-uN$DqzQJ=$tMz?nc?CMifLq$^kpU{8=Z|L*u%b0z`-$K&q#X-jr=Zcfu zu=1Osqi*c-_7ROK{vV4@G%~{~Qi9E1lxrgqRbWknaK$fE-q>;W?54hmI847$x+f8F z24T~<$`_B`{nSJ&r+Jw=;JD26W>aBBR|X)92tsyUB0K*DmmsA}M#3t0vR0)=b3&QV zQItE7w3`>l5W6LmZh{;1dx%sb7jFaTt#?WXb?u3LsTO>SzWYW1wD%ZV_ zPyA`?%UAA0?so(s=itahvt{_Daf`*zHxASU^n5uGYRmiUXH1yzDng~_hcpOZ z4o_Wi^G(k_a0iDdHPdVc3x1PN9@@F61GO9O!A&HMRA<`7X)hu>Q~J18a#O+(K40Z?3C!7#{gM2pq04a& zUIz(G%JjHSuHj@;=k3$HQntCGY2L!Qgla?2XDRy_I6J8<%lhbOi(0e*22W>p+hV|e zCg(DP5+VA55|GOrW3$C!}|Hqa37Y(L47&ySw=(SNx7Jo#E;P|6xfq4;Qv|@0Q{c zn}7Zge^p-0IyBX*l`#yCKDDaBmDU>18jC&GUJMagUQ&M21UVpnpMd(HX_j6^QSR&{ z8(>eCDLV`Q))dz6>Sb9Jun)u6jnOXq^PY0em~82C;XbngkqN z;PwW|f#yQPH~E`yi0hK6$<~3AMTGGnm~TL^zT6!*(gOh#>h8GuHM22VUAdgwTCN=? z%r)NkA21^qYMPPtj-PF_*R7q^+d4au&!{IK{rojSm_F2ciguBX9K?nNY9g!;3FU?Y z5>YuGx7T~gb4SO%)$fvJxCu`1Z^xQWJNY%<=a#u;9fSLi*;l3Z zEITQX$+u!frvUy1K@^0AX`3lYP7<80Bm+@)28mFzoTl(V$QlG9lMgFvG<`g|-OO>X zo_QMi+H?2^2Mr+$7j};OCHaZr33p?Dh721l-cW`W3ZL>Pbi_$9l1h?rYO@+nz|mhqN>h=~sZ`y-$Z7tT+Wn_UywtS;1Ze+OW0InZ1podJETrf?Loy1D z(xtpjIIg22ZJyT`zq{kQ3GHyP@WfQo)6SJ2@5tEPeeiJpAi%rG5T~oE@GN;tt~;ls z&{5>$*}K$rZgb`l2@1|iQed5G2c&IC0?1Ccy?WqYvGnDqP?CILi0%d%}cWD?iMS=u{o) z;;(3sPK_2CIYQjR>*L2%d3 z&ps@eGwIl~{DI7>WS0PCRW;R411E59Zh3UR1Bxv(*B6g2ZU7; z#~MwmGP^xkJRi$67rVW_2md-0w(^(enKy7i8gQ7C_;tA+!#9_RapR$6DuyH($cPz>lVg`A3g7nEWk9<^kHl zhhcL-VIU8L#FO{cj3ls%D_{9iMfjCH6*@=7?v=Y$Czp3 z(LCUGp`ki(M-FtM+hLT{F;fb9(Kj`rjRY3}5g9HV9Cv%aKVSd*s|Ea#A1eJ6F10T? z4>E%+f{FX#V8K%P?pR{hO`s-Zr=s=uO#B=gr$ zvq~?*@!-y$z0DmzY?!4n&2vc~i-NpXaG-0lqU3JNa+fu@;V-0eM6GfW4z}Dd`{o}` z9(Y&<8xb%Wd8!tGwt>lkvIh{1MqYuC4@K7l3xDco*bI%-6SSu@wcRsMFZ%Vd?{GTT z<2?8%)6~)7?-*`;W!JMkRTE+!5VDDMGi$gs<)2g&&60?7OUE>M<)1U{`y&K+C?OyS z!O@*f7H9nV?b4?F#Q*`Q4pEa3@dv>+jI$8fb=5!`GYKcqm=Y&wpP&`-tq{Tyhl(Hn zga$hbNPvQ{$^O*Sz?M{{xPw-$SI3M5T#^D~Q_zPo)lTJ#>IE2!G7BR?lB^ zI4f5L4m||OQUy7b{m$AbdgfBpLwZyc&0-hDeh}i>*I7tR($KdCJOSo3lHTqCCEIK( zU2(&}755h0g0zT%I|wYI%pe?VX<5^*=l=Pvw5Tx?^hdUYp$Rj!Cn$Qda03DTJ0z7h zpuQTo{E4T8|F$mm2N*#@JW;KtGReV0&N^P2?efw?du|LXJ&uIQeVT||X_T>ia`;u| z@n1iD!#gTk@HZT)*yz8RCh92T!TRS^$lf5FTDfpd>EA;)Vuhv-90eer{trn*WEW8S zR7>zky<|3-kn3$V_JjZX5}^tH3W=VLY4q(hZld87O}+$Jp}yRN^o0b6*9PIt?3k7P zx<2{z6#hsyfDjm2`9bY-R6Re~SYSEu*Hc_ImaL5)=qV=-9r{s@APXsNM7%p7R6VkM zM0uCp4>v}w2Kf|@I3pb8nT4%NpT6U+*SjC)k2>&?n%e5ul53%cTnKsq(qKUVgr{q9 z$^f4%4+ntWxkjjhQAk)^OE-3z~9}*A^Apwa_hbtEX0xY(HaZ`>aJu*#dMTr`; z8et8q9*phN{Lvn7@JF(^K}dlFyXZl!NeTcaFLqYzh<@@rD(xgd>{gSS9B~LgJ0T_G z!LiM*{s#H(?R-i&DkmQ%G-@@WOZqQQ-`|rHmP{>mWIix`{g48B1TlQ7<{4BA(>jib zabH(0qpT+12K}%J%8U+4+k&eBq4Asy!g4Y+jKZAJX+=3xW~9|%TQ6d+(WxH`-h1|o zo`d+(_~D=F4umFx31tDbx5NluvB2YG&h8kRRyGhWNov-iN5^%3uTO((kcm8wfAAld znaCwo2H(U^Q+qGg0894c)zfhtRIN0F{mf&}b=r&STH4$oTw3|s%S+yQwL()a_OhVG zV9^Cs;Pga6&EF!zrQj@xOn2mzct|c0ZGB3RAGyT0sOO=-A48nC#?7cg{*_tf7yU8o z@2|2okbf@9t{9Q)%*%6l97Q<}Z8q#|{^N@2!(z80jCxdS5SmoZjV~HsV#HQZesuf) zg%<8t(iU0>_W&Z{aY$eugtjW+BLGtI_h~V)MvIeRO*$kWdDAwn9^1&=&k*^G2Hn)h zrX^=QnOcBJ$nJpxgN0B6m~JB?b*vUQsNDdf=WKtVw!-P6pwsQ`@tgS9Zyn!%-!l`NU?!eeo*xCKuO{Q+=aI z$#0@#l3vBoTZ$f=#C3}I@rGFIq~IvZyo-oV1^T|lR^8~-H-9haz5q{m<@D4PadpkL!P`2F9IL}L zj#Vlg=pFQREuTz;k-)ABR7JJe*3549Q2Wj6pG0J$EgX@EBW|xSp?URz*S6)J)vN`N zC1r!#D`4VLHd2>YjL308Jy2V*!{ch!sB`RZ`#x!lJXga55(muz`Y0VXHZMhqdT%S1MT0MQx3av5Bzjl|S;53NiEl|+dVof4H@+n5Xhr$TV1l{CJBi2nka zZ}eBN4G2>p@*XUDBr#|A1HM}7AV%$h_5|XSP05b1m8DpX5NQf5#O|>d+I;234le`` z^nX9^*&ehCfqST?;hQH6+F^3e0fD$DuaUVP$@^s8r8@2zPm4MNMx*L?4Pk#|S3 zY7XQW2+cL<7xfCe8(Lsnco?h~PD1ZzV(DnRrAz0o{B`Oyi;@G#2v zJN|n($PnF7b@J>lqvy^apaBtqL_b!|XkspH=!M}OO+4J_?bbeRKAkze_dk0UN-19* z`48f#2CeO?znY169bd0qrdcfFj3=1l#IlSciao?c3|xZL)-ppOGgb@P44tf;CL{2L zmU}06eYt4oVqCZxBL2m|LVSe_w`A@4VC&znRK3gL?Z8LoXTHFk0k}F$z+dz-LX0p( zM{$2#G!vvq&ns}p_}~G*&^HhkslZWJR&YzKv+$BLR|rVE{xd%pjRnLIAK68J zxSJKtFD`u#F+cGD{uQ_ex5OSyJ-K$snqK^|yoabgKrTtH<#17Sv&5_za+cIRmhr-c z&eYZ^MRu%~=}j%h`CBq`N&f-}kI7br$KVR!$cbGF(=rIRRy{ecPe*$Ws@0i(`+>Wg zYRqN};AoIkkWLs}3NW~6;?%R*eY5}W>xun(StoQcU@QWT2v!zP*I2}T=_0qR?!g!M zh}+p9w69)}+Ole1#%lgVCMICWWVcZss1buDd+sO=QMnex_kbjskm6=)?^I;R1gR0I zZhu6r6vJ(3(#UN5lrAAx!A7s(*ly`n(MVka4wr)j9dnJZ7Mu*XofadbI;&oc zpVc_THuRpOS9bmC56S$gNb>RHT(_T^_~LEXe)~xRXKsEp&zx8xw3nZJPPO9+;x4=->d&*8f-0KwOh!LWZG^@& zkY`Xw)ia{%k(bNA&;16)|9kj6iKH!c-PM;Zh|dHP9^6I1TYb*_5_btJtZV9*7zfFF z&{F_17mK{K2SVvHhpSfIaK?vJ+6q0g{3jD}HTbo1P{wqQ;4jSLL7=Ub*+Tp|E~Y^+ zu4-qR^3jAuhl&|dq4qqtU9LUX;q0R>(j~<6CcthD*5#ReJI}k1>Fu)jP4PJF-Z&eW zT|K#uXwcqDA-AyR)XlGMH>tN<{fhynzs5)?co&u!2;HD@%f zOlPq*pBgb`-=?LnA@L>Yf)!Qe?%irz-Y*(pv8|$~$48;?3d}Ty7!s%wG%7)=;G==U zd#YY(v_9#kcMz-(b;0VEwQkkX+lm&I@i#i~k?dfWx=kdd;O11FK(8n%(2Jrp+NKK0 zX7OUAgch`$g_2ajt_IAvw0*96^vwu)TNIEvT=F`1KXp;oytkvj)kbJ29imkA14w%! zV+3&+@Y)?V2QMVhv)_XGuXeft1EmGM5&{MxHumVg0Z)DKklK+CT%vYD9$olzQF`l| zz*h@F@En*9J9BFi38>l&(QV3PylZtyx<^%Xmkq`DZJn<{()E4liV?EkO?mW26hn>K zIv%_Rp=Z^7AD54q$C$|GkX38Jtt7Zp@RgHH1ms}mnEyi+66EHJ5>u0d1+$+6*0{9r|fvE)0w;8iESLDtqxTfU_Ag8gXOF?oXTE$`DOoSv)k<}jafVWXnZz3SreB?kIuNZ z3VA{@HuR4zyX@}Fu^ZwzD*dgD@m^y_Qe>HBh`XXFokT=HmB@0J!#1YG;VHM|xSXJn zyFKw?^ef|tONYDGAPlJdwDroEAG&Fm zM2iZ=rviZVRxpA1Tz9_4kacc8%D1KcYwJewU$2 z&)U0hve@RipEQWSK8{uNP5Zl6{7zSxWXMr1ikKFYQ#AX9v>2gao15sK?$M5-gh(C; zyx_aorQ=)AlpKh98BzveVC;xAL!0euu)^!l9AUhpH>piSn3!tA1(G_<2fSdt%8TrU z&Kz)wxW|H!>?N@Qd30;Qt};6d3rnbw$lK09V?MmYjF$=EH~XieOX+W4RvyPZqkJT| zT8?%7TrGd5)~_Rlh6#hJnl*Xt!x^Q?oS1v^@A?-au0`f=0^2I>l1tmL)58`Pvos?m zv7(~HMzfsEU}+u=J&we*0w^NvE`&-%&;^pbs%DOXnUo31R->6j)smNMA+eJWkdJ7Y zZi5&nt&zpHgu+E%m47~>FER;bSR&TaQ?4N{(V$hYEWK=C+3mv2dB8Q9YS`Ybr z51~=97(qB4Gu}h`zwxRo@&^V9C_>3BsH*b7V6_Ll)Cm> zMeXr?K!6aEFk#3k;RnYD^B?|S$jR{*!)XW>MQosPPB}S4s+~O|=bHY+m@JuIE`-G` z$dZ!21fq!uHc8I>0vG&Gx+DE(?PX%I%3g-4d8lD!#&sX z(~6c-r0$xXRC|L!vdcf~;mdoo-NVRDuxAQ_h@>4M9=91* zZSH#Ol`)O=Yh#hKBN&6`*{Q_1Mg>nE;AjN9FjHc)%c1E93AqHR1#HF-4O%jJ!(V^= zftZcq5aNI{FbG+v-u&>r-`9(S`J)be^z$~<1YFJ9A=DqprOIK}4K16r*;Z1Ba3LIO zxJG6zxpP2C&n&c|_LShF&gwdtBF#2pii8ATh~A}f%V4$!ZUfpF+yKnMm6#1R$oM6D z5%OtBe6roPV0_ETWA}f$8#fltpqwxI%U#(WG-jx0loNa8+2jXTCZZ%IW12Evl8F(t zh?uTst0C>scdfl`fm(0vNR5mxm;ec|fpv*#9B1jIX zfB<>+pN7Sqcs}5N=~Yh@_zOxLV)S4#_8~JXoo1ut_^6RsyACJcgT5{R-2aDc-UY(E+Ig)O`oyv4{HZjQ)fwDoaR{9R_Y|(salw zI&D#;8LO9XR5ixYlv7N07QC*XFe*ks%TQiKn!%{GE;Ot}nL}VT4Yh6AZl4?BnbMjE zlnKhcq`bxzIA0^~gm9rK_Q}O33bHd^;a@GY&H8uui$QxVizc39P=l4@Mg@{^u0^LJ z+IMXAO$#h}=r>bpC?uw3wv@p{g@Du8TnxQ`N(+HlqHQr5P)C#cIpJsnSu6soe4bkV zZu?iRa2!RJIYAG!%Fm*Q?A!4^8fg4L1EEkPv8UR~FSF6o&10eF)(nRa3Q-rkJ-$IH zzfZa7@~@?6S0ptA0nuU*imU$o_OTbYU9(P;1d=4Q1ofelRAVTtMB=ij{T;%#(j9sJ zdlRv%#S#LX=WG#z?D-feCM?DaN1P2B`0C*2qfD`DdY9RoaRHRtJ|ZDZ7*m<|w6$B| zYuaXfIr=wb+Q1q-%r^r52wJblBSJxQ2-HJwZL7q&x6B=q+#LbbGvkkmU9>zhZ})we z!BfE33N;=??m2^(Q@QBgah2=$?YM;hLN%TW{2FN#QHMGMUKjEAZsecq%&&34_Y6XL ztKXMD_}w2zv^_nP?1GE!Gz{PDEidxf%Yf`4aEp0;7y*Us>ACg!SEfC5q=!T#dTS6S zR8)4^RaSgcmmPdE0b&C!Q|zK!6#{|caz~9eCgt=6BQ}`GTsBh5(dR65_*e0UiUd*_ zZ&J{K89-|!fBjPlkYKW5^*FeI;}Wl8Xq_8kbVX9BaUWWte*VU>GZJPud$1)E0n#b1 zCXTqO6B() zC71Fwnj+1TDnPQSQfuMsQziofWEDNM&onADL97xlY-o>5J73#+V0UE3b5eyooIVzIG?~5_Szz2zXegUT5 zH)bZib+}^j3`7m)-G1E*;bNl<-K0}bG`!k3=7p0gTmj{=qbI1Gr-+s0s+8)i{g*8x zwK(I7Y|HO>V9u>0uIPwM+d2?;lDpj?JW$=`;s=&BI~C7gMFYpbuJ&5|%sAwXFUg?^ z5^%barbHq6+KAw8EP*6OsP_h}HUt$olE3Pw2J7i5>Z9GSLpG#{<=eJSJT|LpYyORx zi-o5;j*2y@@lvMv$yo~%CT}?11_L2G@Xzu^s|Uj%+g4g44>J%%DbBU}H0+6eRE9l$ zP4U52>vFGXJms!5jzSrgOuAz-hDMwKP1=vl0q#X`0YaQ2R5=1vX41RamRA%3PdmKu z)}hX=x<7|IQZL&kOqjlEScAz;*N?`7w2Xg*iFRylRZ$BuG)w|CM;^Ck8c4z>k|AV> z)MRG7gHW=HtNC|Hw9tM<@V*5<7)kPze%Ur{Ui2@`qdRdFp;H10_B#FtP7Uw3z&~`J zD<1#PTq@^zu7D$d!0*9*KE3LPl4ILH+FrpQ_>m?nd{9#eV}MX%)DlYAHdYaZUI5{v zJ-&D@C9>@ehylre&mly}4Z=fNyPog%((jjMX~50`*a$TSk*O2`qpJF)a@1%P#17_+ z28E>Y#lxpo6{JWBZF)*?17SvNSk-37@{K4`_+vKJTTIWFAh2O{XmnqQUIgxVWe<*M?Bet;k_f73$(SX*IKc_q#3#e!t>`DI{U^(C?F=79k zWH{hFVl>E@&|VQdd_LwX$z?kqUX21q<<5z6lK0HLUG8kV3o0Y4^rntu?o0UG{dXgj z1u+;?IdWj70at!T*7lFvuAlNpfBqx@vy9qQzo~NCkYgL_)c9N4L=)|4%EGL29kYJB zsr{}e+ux12Z7l)9{*b^~b!76X9*36oa zGulR?mT4KS)w{lNHu`zRB(%RTRYIk>M${REM`Q0_(RSqIHkhNOv6jI^es0R5jm7DT zM$v*vmI8Y@XdyYHwN>T!_mr)9rtB)IF86ALn}aEX_gHNFqm7PE*oS5PWgJrDz$mV_ zX~`&R+3f-f{bZj;41}^exzq{CR#)w)QG}IofhlM?SWpE4v5*uE@!eocfWJ+tHZuf$ z!v(JiOFhvJ`zvX_HBDTI%2phgO4Bh?f{f!Qs}s-kX}S2BgZz;{3Dk#~iC9$#m0y5p z(-L!}U$m(ij4^fy5-fAqy^7jXtsdz!vftT*m6#XmTbQ+9M#; zxda;Lg4+CU+7zeZ63bo4bClK%^;*uX%)4gk>$|#Y#Gu!U$?!t1rOD{GmXY3)Y{CR< zvO6kKCX@ZsmFsW)qS@KKvp6T8!m;_UE5%yAV34CU9rG+F6oQe9avf!<_F_Msw&t)_ z$`7rk?0U}uC)=HfhRTMyv`4NPjB2^=LQ#ZLfG}o|z$H?SWsu4aimVMs+zuCNlxgRg zR*o+_nzuLA^U0#SAh>+#S4AtDR?#vV-NoQ+A-=)va@xt9RW2pE|92fl9*W@pW@gryF9`6iAMnH5vnAh#~E zf#xP7(JyuC6d=l-0=Vo^tKe}W(Nl2(L#ApgC=AmQ6u#(r`O(4ymGkjX!7&icf}bE; zRk?r6h=X7K*+PYA;)l9`GT8ZD4XBWgfiiVk4WNHq4H9Pqaa3|UZV?h$Ad&!N-XbE% z+&pM+_1I7E&PLp#P^O3DFkw#hUulg8ZhQD%j$@>Hei~hviU(=|^;{6dc)FG-PR)gS zWoig6|FhK)QdQC2xTLt0$dBe!PBTAp()$1!&g2Co&Ky54rmkoRHMF27UM_FZm|fy@ z<#J1(C4(whBzFZPdm%mbv5wR7zCUf=iYG#W0yKmyOqg4lcjfFCy55AXUu4)Qr##QZ zRRbNUs_Xuj2|y#fzZtGP9}&%SW3!F3?AZ>Y5kV@U z(F!5l@uYGt+Mqx@%6EKxXyio?TOaI*jOE(i3>q9?!tfRakYU1etF}7-irx2vMT^m} zG894mF2s-%!#ybe#v3Nn5vi_b+mCL*F8LCx2#l8Yx#O9*jGltURe|8k%5sUyG7JPB zEsmr%4%9_`Ck?4WEtc?H<(ZD%Qf|H5!B<3gS%0VMd zNRAYgi?@MB1n)YxQl1CstH< zSfPclOfL%EL3XPY%S>!$rv9MtxQhbRR;~R?bKXTU9vV!zJsAb|Vh1}lFiZ?vjzWPe z2O$_eJ`})MNEhro3Z2D}^D|%7z`7T#b3vuwHCg)XV_(d}J<^;E3!+{vm%s%Gzb`-9BoG_nI$| z6cOE6wi;)PvszR&U|jsf_I+`m`!Osjhg7#UJov(LU{86>URV>m#{?!AaxFza+Q4GS zntQ?@;G}TmJ3J(@^ttev-;MbE=$*)A+9FhZMBu`O*RqDqJHBh&*)RDMKk$Ifgjn&x z?pN`F)O%nERV_eZsd;5Zh?1015ws{gSAz7F0QLi<@vzR4rdY*+P!1vj7#IWwLuGj{ zl#wXP4;OR-WthW1+ zp7r1{2+LNPeybR9<2Ca%R}Tv>=-a{l9Y+!+YqAD*?ni+&FyAqXHJP&xvJsgGIyd+t zrH*nmtcTT*2p)cY?5k^|cK+5d2PfGFSqz^F5~x9V>(qEt&z=c=(30kl_Ec{UH!uYg z=~Z>lED5~K8TBWV1X%C&uFq~eU^cBncog7BLYYB$J4=}QMOX2zyHrRAVI`IJs-hYNQ7vfo7!cFQVGPALLC>If8MdL;3#jIwKjuDSZnamc6IaB49S0d-?^KO& z9N$q~tfd2IavfN+n!g!N7YIp#L>jv%r@)LNF42GbfwY_IE_I|rS$zOA+GfEk5F&Hi zH~nDD%^RX`McnBrX9nTjR$nZf{As`N?^L)W0xbqx>hRKY?_ohxqyhc_Cl~FZlTBKD zz!NdiW{jZyJ}@vx-lk$w;6C+2Q;SF{4@(7jM3G$wFQuZtp;u-d&-uEnb^bCHekg4b z1BM2Z@ox_#nn~9YXpak3jF?+mWSxSb*oF;6))JRvpiinM1T9I#(Kd4OG4CIw+!Ff- z^hWaf$C?wwltcX$jYcS9oB}B(8|@i1ZGqu%*`Vp+NE3Q<4inz1d}jLMN zCP?)kZFNfa#e%M5P43srmY$G^$FVjO1L4Av2N|#AU;4NEbm91yzU@63p=^xXiI2Fe z-dojW#-%?tyLcbJFUx9lU4n?6|7yyoh8)YZer7`rDZ_KDD#H^ek0as?k!27*sB|Cy zv!vbZXH@7SOIlGIy;YOoX@EvljvazC#OTDLbQ1qpLR6S|a*HUlLFqs#=k~W52c=#! zf4CtQxqcGPNipIS!-Tb2$Dim^**qTK?7-h-ipW?SiHFwOsvx033M%T2q%BT7RPcg8 zqWnacJ>MJUC@l7s1A|%}`QzE=7a7q&B%siN03jr6t43|K_WsPO8{a~}2zoezUkQ{8 z$T0J|i-?m2Hao~Dk%N4B7OT4iwEJAJ?3kda%p_;q8=ifvOFEjn3NK^8EZ{fRU?>xZ z5kU+W)>UoGob+Mrw4eABe`H;7woe4~`U-9^QV#2`qky??Rrc)-V}7{0) zi1b28y!HY1QfBf9(|uOS>Y>;^lF0dSto6j21s}J<$;o8Fjh4XXb^RGy-G*R$M^NJ+ z4Ok%QG9Y-)_I$agYRx}y<55`R;iyvKa((5aKQ#5d`QVEhxU7%e>@U9YBJWYmE`SoE zSBwG|jV&+FMjH$TD{H4Gm#mM?Ik>jXAX6rvu0Xc-nkF)cZpxLMY%x$x5^PHz z5=)T7I!d#G?~1g3K>t4(%W@+}p1HFH{~hj_=U0Mo75_^aUoX8-!yirfbBq*FzJ4jc zfy=Lau6JKawD>s;wN`!(4+Vp;p}Kq98xKaWSk6C^#78(mNv{j$uG2a~nG_3~k(30i zS=yBw@a2NE3mw)aX;;7NA4s*@(r&y$+RXuJ7xV=iin|yEgJf0Hi0DGJgb5p~G9nIF zMK_$lAEA`R1dH5ykex)Z{ktHrQEHxM?Qgr|^7eDm<|KJgKx)PRz)?Amjnz}1ziRJ0 zGyV_u4sfwRkpHZ=T-`eWiBP#n2H}&+(FL8;;uicT3V1}26nEY=E|UK3$It0CX(L@n z*~%b%TDAJ^)}6z4jpJyLUBi^yuw1vGz60Va2}}csgy?jT=pCd7FEDwgbpSUHF$Z9A z_26kA?yhp6M2+etj<{erB9|}-o3fgmcuO3!2{YU}@K@;Zq~kd-GY1C)QiHMT*q5#G zw*DmxZhzd~{bgk4dTMgGu(_(kd(-18DyMLGWVndt$8B}G9su6Jj5Rb5!7>h28=?|O z^K;Pm;BV1HFQ5gw1Ntg@NQGp|$5<{yj?3+Jl+SOGH!r=TRQ^|a93qA{SGS#%xBRt> z8}cd3To{NYQ?fd0i2!P^HaD$OO{_RR&C;tV%AK8LgJK>~Zj1Le0_D|9BQJ>x7ENkH zfz}n8j0tm>V$|s0ej!oncF5GtLB1GHEfx|44lf7j&2YyAjllw%7K@Qki4QD%#3@GJ ziJ(#LjZ?B8?05W!-|;YLgY>BwC1l2yw0rWdhL0p^5QUtg6ii9wNzD-SnC~b9KtUbw zPxfAP;GaJxekOHkjM0H3T==ZIWs7@Vn;RX_fTTV|*Yl`|symgJ1a>MvH(m6z%AI%I zRy}X*{{MYUDXL!^OZ@w}pCgv44{i+)@3O6@29_XWM1#qi?8Q#H`=H>AgH|RtvjXL$ z@E+|UVDs7YM_4~AyRv5sNg2bP!+%Cn4GqHQm6sRJeeIiTv$Y_oV@Xg@s-RZ@sTklb z$%B%h+Uo1ID_XC+Z$aV)JQVb-{^7!wSkIo}Eqspug2EWQOjry=^wl6>=+#i!(yHk$ z^LtOcJ5+NaFu6I1!9&W!r2I`ZrBO>EXLDjS1Qr1gwv8dU3+jPBh z+BN)p^)y0+6G#5KpuDc>K0ZHRC8U{_0hU?UO4yOLud7a4N|ch4oESC@H%5;C@zBU-`%HL#BL+};Ma<%TgYea= zR=sCcjcTQtYzjU_;1Dq}eflRv_f7H*ff8;_ENG9Uis4r{A_5U}24VZD zW}E+f<=K2Yf8cv2WTU4G`-?3iUUj20stQND%yOMDnlURMaP)?^f-7?9pRWUPn(B8dU%F48Q+M z*&A)?iWPSWP{v69okLaY26b^9aYuwY;?4;ZzF(CTxoS%JYq-t*c8(Mp$F@%}RV|># zDNkAhHzz3#1fI`<5Ff$%n*!UU&8WPj)@kO%kCzP{Gz1H<2z_xADfZ6yRlg1{>D|xK zS7YbU&0V7_#6Pkh{2-zf*$+WDa8?16-n83!G->3`Gb9ic5+5SWApB6>(A&H1-+i5G zXo!uO#&E{O4bHZ>qK71p?r$@>-1#6905-(Fj#7s!(Fx6HrIL#3V+2l7?10QGJX%O| z9#W$TT1~mZ<4hc?hl=Cc zTS{4j92b(KL=u?y#BRu1G&Ab%+5CZg+)-SyARH~r58bnDk^vi+ojSx_5g|7=U{YC7 zQw_CC=Gm-6z-|WrL}lbatqD@Q95#{-)CI4#f>z5*L7Yni%lxCIjBf4DYhX-U`r5b8O-Sgz9%rt9 zB<_zjKh*5H{cqz@n8q={G%`N#U_6#Obt8$E4(kBXqr5tf7(?nPLo|ukHrDNdY!q*f z(+Omk^-0X~ANPIO427oa^vHw5p*P5D_sglVcNZQ^n6IhqGIA#po}*%P-yx-$7FThG z&0Odx%qj3hlGws%9$`pB3<*J#l)GX(Z3StxnG;D)i6;h%YvkHU&2>O-i%YI~>YjyT z)**5gR3+_QgK(f#_X@{Vws0$-1=jOt$kmCUQxx@zqBXt5NEZt^u(2w^@4lLI&sz(> z*_Oh;`DQ&l{r~&_DhBin5cLI=(v^-(8AsfP=pxsHOWtk=PYGv6zB}P7H1YK0ACYOA z?6x4bC5SmD?IIl>Fa;3Bmt?^t^J_?HggZn;qmjphilDn=u7gJZB#5LpV2&LUdYq7x z0eZvP4!5*uwjuFT#PMFfA+tI$klyEzP3X-3;DbDuLzQQjEPc=XVFiC8pRUB`PYOlF zd-DeMGP=rh%e_(gwisxZ4X$X13%Zq;7h!H&f4CVB_o!<{Lj?~kAsSacD$)kcL?MVx z!z8=vr00|Gqmq8b_1Ptfp?Y)pwd&B=@%O#o`Fs9C2R^d(U|C4IY4Z&Kbt+|$Zo4q4 z;cB@AtwjmZq#uE&)L}JN*#3Ut*AFhcaY0*T!bs?dCS2q&;kQ<+7TE`G&b0GaWduKc&9thzfVjgtd=%8K!$$$^AwO6G8t3?T_~0ZO zLVy{TPh|(Fwh$X+sjQLxY&+%;*xvn;LC0~4kk=@e=(nu7*3(}+zxQ_)1=9s$+b~G} z-~c)+CZPo_`Acmo;Gq>Eef}JpI)Gj#H*OG({$^1IggSvrQRYhY^768lDLiO1;nU#N`1gm60h$9>kSHH(T zd&R&rhvs7Nhs=bN{8XPg zlBRSm!puh*^e>ApS~|Zm8jDBr=hT2!mzv;a8?6Z*LmIz9trVYwganY7Zx&Hc?m>?c z$l;~V{+RJoCFw|PgP$K+e?z>c z}xP98huP}faK|o%5gzimHXpv5TYvG`;gVm#y>dvkys4EU#-6A za__glKZTX7{1-;*AfPLI(e`PC(?PJ1F_}~@fGC@I@T;<^)O3h2jtDK4Pz)m<3!TNH zP(>rI#Z2e`I54^3%vWKpQbJ%qCk6Hc`1G=0L-8+&D`$PtcfJpiaV$|#Zmbl^8* zN}L`jXvl*M2-tKbKp}9#0R-VkVnm9goL4UZOS5h2-1V=WI52((LdUZ`5I9NYK5=So ztnkL1fdlvx|AP^0?gURkQMN2FLH`7i7R0tW+)l=$U^DD#{ovQ>|0AgV)7u*vRo$d4$vYbbV{I@!NBmq(cnYa*=A)#yLSUAaH zgK0^!`!fu0F5i+QrIumwR5g^RVhd6duUz-kS^fykLjOe%2_P+KQ4A9P&P!r|fTOU2 z)~4Y~iOSKTG;SjzLmg$ZI9IdkgWS!nod9+3`UMYMDAd!jMp)S@FrAcj8H6~7R?Ib_0Uuq0;AP5#-f6 z=-#_vrE4f-isHu`_JATDDT~zQ49nMe-Gx*hU^`N4<7zd$((HT-wQZhnaLF~{1E$%K zh?EIDNJNGabB7)q_S7CcMgwV|#gCDbKA5Byd}HC>^eG4s z8WoYaC4huRr~B=>?YZvj!}+T+NOY}g)g8thkT@4qWPx>%g%UGgGNL(o9ANc>H6x!6 z#wc~oGUTJ@V^vMIG9mN&q{wy`ArkdOH-m8TX{V*h$tf!z<@hb*BefMGIJ%CKdC_t4QN4&2b)pU00uI)4DeBW@igFlkbV`35}6#&?x zg-rU2_L(G=xgXfHSr;rQuK^Wcq&S35>7C13RxP^*W_RvPlRVKlg#{)j4?K;_#nEk_<%f=uY^|x!|)7|fQq2xr#e~|_vQoSU|R;SE5$&4Y) z56XR@>dyE=XllFcJVAbd?k&VNasU{0YXb35;5RVW-imM!=KvG=Kb3vEv+7)!UcFw)4Msyk49xXqcJokV+a{f@i%W6soG%8y|7zk9bUXTQ zKSFgnIdhEOLaer@HWaID#0lmC2sCzhptj!Rr9b>QVNLN!H-mJ*YZ zSRmawK09=tBz@9YX)yS@1>eOk9p8GU31_coiZuw=jZb`jz(eiFaT!PNok_3L$V9#-e3)y=|hT>fSJ9UA)>&jQ^QGJD-6o*Yn2;rydj z_RRL;Vn66a3cps`h;+LlA4EF~LP*9=unq&Mkb88b zh8NUXd*G_s4}azR{UX%iF((fZ5bCHDX!Sma6w>~V#Hty?ei<~4znI2H?xQBVj*v$% zx}{MDmK=MruLMGlC?3T~T3bE2D9_EhE?S7o8bYXD&K#%DMhmg0>mrkei<#npXF}qH z-8O6cx(}|qG4l^sbfnamogv)2>Z_4&MLAH8|N0(xj;!0Cq$0oH$ajAR{0r z&cezSxNS5yE*pwC7J(z~h88zIp1k*GslBCsR$S*fQ|~$uGu)BI3ID(BNh0gUIY;Q# zx6Y--G$$0TEzM{zo%=``JF-URvHA!B=16}ZDapslQ@N?oOopT0*3r9<^ws(Fkv8K_ zK3}D2WkQY_Y(oVYgJZHG#u|)XB*Bqb55ZZL=gg0R@+EmR31w!dsXO;CZT&EEOuZ5c z2BGU6{Tj7jJAQ<23QkQMJpe9pK_N2rON@h~)CWgsk@uw?mma@mYqLfO4dMiGhSy<2 z#E8#2O&Ry`$U^?ee-AP~OTY;d87pO72kCoDunk96bg2_km)ssKcOOLqW#Bx0=g)pK z*G}vohT!U%=px3)nHOLDd#gAOtc8!{a3{YJL_Sy4Mi))IHoCXGFx&0=`-;qI-@LH7 z8Jb>^{Ug4VBjV2>7*9ua7`A^?=P3S)KmHgb4L+9>rtzjl1MdAby1NE$65xl$vKN>5*c}T5 zdD}>QXmorUu5f()SD(3Fj$K(7J2;BgZDB%$dg@b>Jgi97ZduwFxPkUROAiC0#g;r0x{dw@3J( z$}Xj?34qwGOsU7!R!%ZZNEp$^KH)9WWRqc`VC?R3|uoW?f|CyhlLJ^T@Ly_W@puWvPk*xht~rm)!&qE@P9TTkh9Yjj&H&C8okokiBoClhW_Fce?M6u z)c523I@hEjr(VN*fDKN)N$9ok&5@n@?6Ie4`bZXY0rj(m;8a$o0uI-xeozYt9A7S| z2>=inC9ZskFb13?IR5RY?piBGA8&%hjKB~4Clz8+hVOa8wEeMb(asXMq=^7P;=J|E zM+(e8$(!%qH#IfBT2TKYge4NmCDR32ou!d$tOII1bCsMY(+I~;LwRbebJs^VN&o(g z?l5x0MrdXsYyDpeIOYfHrB5ajEyXT>o&o`D?k!DS^>MAI1`Vo%ldLupDYM;oc-zMt zPrrR3ZV1 zGasW~WW$Y<)1|&vdeDFPq`7Ei7X|M>$MhMtaOk@oT{7oPb$yt)RZ`MSk&e$qmQHEP^1VR9jDkNmp2g#i8&#O zq@dXADCAN|5lanj*}vXD*+WL>;$pfZc#z~Pq|hV`E?VQJQ*sy4| zkUT1nKC1^xk{<%60q7H5A)@T#Kse#`H$h`7)>xI*Ln$w^Fh3}3am4vkDS0PWEWZ9gTnTE{H2d~ds*7nD-{2gUKBGLtJ+d6T<1V;t_AL2tv zXfLl#E=Ko5OFpygvtiQgQeZ}=7_&Ce%N$@!!)x=y!!NwC^(GlXxs8f)q`Rh&)#|sG z26%2e^nWiFiIxJns92<|;ju$AT(5n-Jmj1i@aDe|hXn_o5^W%Yd`l8S^C22e{jRZRN8eTh*A51hqpZSzLT*rS zlW*`3>QH6;K9k^_u<27_`l2-t@HZ#%mV4b5yxLI22f5<{1LtF;SUAB7L0R{4y z4lyU{P8ioGx^b$}4kvH0t-* z$=7iXPpD`_5+j7som<|%{p{zvb96{#fHNW8(z5kUT@IGc7(~D$niE(K7_1X7Wm^of z#WrcPf1Y&QtpunS7|=O-;kX$s53kH0#-AtgmO6d_WRR`*@HmbQB$dGF#{kA5f!j2x z(ox`__}tvLybI@liH@3NK9=~?w{sG3+fZ)jM9a%dlRmqqY&@ zl8y=ozzi4{!vzHcs8gK-G@KyA%D=s=3R*p#G{5&>SKZF11WzQo0U2pOEQuL_g28+M z`OlIQY;#_S-y-kp*zTCr5(B(Z`mT` zYcRZ1Dhz!GNDNUk2LR`bNf6pcKi_feT*KW(wa!BD))auM@S!!jY4pAC zK7%$f%-b|-k$ik^bdC41MOH8gV_PlS(Y;-hyeIghz>&@X_c37ajkZ~G;)jm1LZKni zmk&5YY(HQf6vYAL7TX)>G6sxUI5!|t4G@zZ<4TD<3Y9-AMVC?`E$LwX{oVLbM10x) zX2?7@VsCh>bgHC$>5v^0kJ`|V5zr|Rew6T!tg(4fIUZN+XaLG%b&A-(Ts4Ckw85?c zp{sO*Vso$Iak}Yo%;#9LuR$^f>}~u5g+z(cw@8%T_Hm~UU$F2xUba%t0yljKeLHH z3gD6ebIxT_nu8Lw%wi!NwSEBp$t=oM3VDtX%75MPyaq1~ z*6B6dS}WP%K+LsqkX^dPiB@9AVu}9gUYAoeXF-&g-^oJGR<1jq`a{6~mtCsh+NOU&H&(5%rvfsB<1?me2!`a4fxn8Q#pTDMuxdBw$xc_hIU7J_ z2|%jH4FIV&DeCq7eaY9(n2VCgoqQOOZIEk_Pp1t3O8jf!S6im&4p*${TVPiv zBkihI?#hIZd#(7XI1^1#-S~UV6lJjHNPQYBae>maUQ=c&j(SHy2x6S+Bk1?!O*-QS z_IiE(>M(0%m+xw<`vYb1Bu*VpOizA|Ex(l4bq!(a@V|=Zf0^`zeq<+} zwTc-c7KvX;^<)>hor!Kot`GCcx&$PTEy<3M4H>@fBGkDJd<{^=3J zB!STK1>Fx=cs)$EoUS06iB%gjz<;y8HD_b~CVAAbRHvF2lQ8Z4(=EKsCjZfoKWfig zCh?%JC8WRu*>pBQ#4LnhJi4GP1fmWPr!1(C9 zvAwD@F8?u0e=IEqK4F?rv=mD9PAZe|*g{uM$=9gbfA;u_JD=tJ7Px<5SeTxzu`1`Cd_ZVL0%rfA%Qu=H zf4YaEUCe|MAL{e4bB}>7Timwm3futICxv#2&l&z{ote{{4}al5vADR1r|&EjEhq_A zZ#hK>b30$R#8<0-UYTxZ?bSIR*+lBufjosi3t(=7yTaes3u*bFBI_UfZ$2?$%f=Sc zNaRekgs3NLZmTov27USNpC9oDL55^PM+iU~iYP0Bs!vh!C5VauwZ&IWSytC#8W`=E zkZd2wHFQFiUUUpk9s|JZV z)9+xGDz-B+s2wwNj!BTw@Av7iuGz2GdiAIDIVkp6@i`M^RQN<^TPU1E@TVi&zq0(X36gVU=-BGwJd z5Cut1ehKugk}#cN<6zB_x-bU8;814(Qqr=6eU{8m1|@@|U|7&shU*lMCFBa6eUq?k zVb^EA`PDZli@&POKg@mxd>tEVoy7+Ew0beDbU*&L14ccC1W29o2?_UP5yPUTFTKsf zJFCt`^e>D!T+3N1%NLpFlxo%RNC1B({AtsNcaJQ*u5|%UlF|Nd5|)?0+_~;=30K(p z{59f#LUt?0;h}c-;3z85Of|loVp;<3v1cA{+1%GS0fBQ4Acv@0jFq}pb)WkegbDmU zvJbw7c|cB1F{W(e^Xj%(Ny^W^cP0NKbaZUs*Qlani@&F)vkre?5}sf9S@9iZf4tm_ z-@!L!FOIRZjbw3oM-z<`&L?0Gs}z$;Z@@Zn`Let&$oGao4X-!uw-H}FdI!$?d?bpu z3N0@j{kV0fTkB2sXlWsvGtG5}l{vPbr(g2etk@y_AdbP22bI4)UWd<>HJX}xprRwF z_mF4?6hVAT8ovV31a9+-uX6hEqRGNhFY92seOwYOI_DbRm{RC6LShwLI%~4?6P#k`!Yg zh(ri$I{&cpr)%4Nx-YqEWsJ&{u|FYHDB&_XR*ZSi}Yd?HY!xUs$QDkHt z4M+*tC$vJ3Vw?qlB;<@qpp6AgIII(u2|#J_b}>pCB}xVW|K27SR`p1Y+<@HO0(-z) zWrtYT`FYQ4i}&_T&~$|K!xhGgQ|l=KiRC-a?Yi#9o6K_ZDQ>PvjY7uy&cm|ff1P#; zy|h8BhOk^3DJL282`vMgR_b;y}VHFKy|7bfZ}YTP@u$Elm2T zwBv!ok^E8cVHb|-NZBWr&j-ULWCT+Qi*H5c@B4u1fs{a)@46W zxhVmKP65YDO<@gTW4ZIaMT3Q5HXRDdeqj{&5}oNOab`p1tvqMeXbFOga|;NP&R&0c zQrWitXK-b$ID((p_ajShEPutha>?mVOLcxW04c%v=ml#Lsl5vsiP_nuHjXw=c2X;V zOuAiwufqP*(H6tRmro)4hiHbB6%Pz>kcFRcb+j#WDopoC* zX@^DwoB`@rgy1Pp#^Bx_`=}wlLMhgt2l4-7odA|k%`B1+Kx>eCjc1Pfx_th8zjXlo zlVDGhre68_J*5vd`UTmt^0dZHN8kBkPvff>{iHkkB=n8^7fMef5dG1_W>`wboFLf@ zazMFNe*(Wn{<^9T@o3W}`kwzJY0^-f z%8vMfj|%dtNqF^W*1~soEZVR{cf7*(U#2s%D?7b#^!2tgt=1H0hw2E-QaUPDN{EFT zeLjF0bP~;Z&Kp;(xU=4M$FXCWL(01maA0pKuTyw!zmYd+4{UPI5l>?XZeT0`YCDr7 z!|$bz)*Dnnk=k|aqF-_^I`v`3i^un1N19;|c&kj+)>coa-_+xY@ZW}DNG0Vjht2Aaw?>Qr+cYD>llM6{@M$kxlI(-qz@CGaG41js~7Ll;%g`K8?8 zh(rkG<+sl0u&()A>HJxH-cp4Nc`cNF8Jw8A;391@wgCyWYm(!h13@>KMk)D)$IxRzvBuATSUDZ_Jh(`#!%7>PZ z+0^IuHT;eCyk+KM40O<(g)Dg%)9PT9iT+(3p!lHZvnb%_JoIYkxIGTP;?))bbOB(O zBzC)cUdLU-4~{%e;XWXahDUumQ9EcX> zAGTU~{)H)%({xA*ASl#esWI_r>{uL)V`6d5h(dR~Z^|7<=8cI%l0+OJ-r_i!gnj2t zXr zq7LbuFOC$p+j`6A*K=~Q8!GBA+vVl@eT7x_w;Ho2ZN%$8xp^OzB}L_ImL#sTqS$mq z^Qc=8yqK4dMuetOy&42n4PJ)68@7B#O3VfOtRBeN*y6A&)E*daI(%qpqo4coM@hWp zQg*0xDcEPB%o_<870smL+W>&`CIth*c`tZ*zZkBI*mA93(hGI5=VEh8mV!+kN~=fTAS(B|~rA%rpf7T3|BH<#qrIq(Ly9 z0y+dZutk2CTLJ54)|%*aVzWtr7eHJCi#PpqjzIu_(`91- z^6t{^RV_~W_>=a$m1iIfdj!$a0M>N?Bu4@yDHF2|g=Uq17>rP4mFL(qq`K4gJmuTG zOD=7KXE@S~Bu5CJO*rM89r?&_g*rrMP(_Fwx#8td(g78%Y0j)7FTvyLS>*6SABc5E zmE~_^cobAO0f;P*&zacQpVsB*brs0q7-*@c__GO_jUpS=zUzBkdM~}8PLvr?euCw7 zhZhk4ARNe*1y97D0H+i$-{}WtLa^MC2g$*;;Y17lJBd}K_nBR>0Y!6czC2eBOs6Y1 zuexv~CgIS8we?nx*!6Rw&R|vQTjT~#1bKrFn5Ec$9A_R}Aq6e6nmlyWIRJtF1P^i* z|24cc2}jR2srP)|XTL4hp#!A+vDCUVup~PpIXN#rc9awYp-2UuVv+y|NY#}Heso&` zt|R9CWDNApqY^V05#yaHEP;30OAD-5)Nqb;T5wBx^L3fg5L~^ohK7e9!1JZk6soZk5=c1@NUm@9M{GcKG zr}Mv`STc5m6<2m3*_0J^9cgBQVg#APaP+tV{27v;00)}-)jk_{;KbuwZ^f;$snwifeUC6$8Ap=l9k zNa^HXM{i3X-*)iacmD&O6r&W;!fY-ENncI`mqiR~6ua;6Ww~6KCQc<)2yeUCWVFAJ z0zQ56F#7|#gMq;)hVpbQWKuW)@sEHAQQfRJzlN}dEGHz0z-^lp%kFv##5hprydV}b z5s9S{hLD;oGTUCgHDgK}w&!n9DR6c0KmKkQh7UA(@W0R-0T%3vwdUxHFdSw8 z#L?skRL9NDLB=2gk!-~-h$tH8901PFAV(u(6>=sN0% z)VxgImr%&o4tULqnN1qbx#z2R{wPUaA;d>e2*Q3y4FrtsbYqRCU9ugN|wu`|NPW{#DEP{XCgMm?cbL(?3&K7F}=wZCIKCrDz$Gf&8RBenLjt zQT~8GQ)(=kMJa~W?BW4;w5;@JeV_ex&68q%^pT?x6|Z?;Ds5C_BfpP>WD>4Awz44W z>CKPnP9$4Np$>z{yl;J2)UO7GDBx8XIO_Yzgdo zB#YJ{FBU@Ujq+l_cY-;w$bQ%&A7Crbf7uX!-^9$HkPF-M7Z^7ZH5v{dbIRyJu>XyCRIz>f{-cWq zmGdWozkE4NHb8b@L4+XGL(#_kkrJSigHf8;3HTi!R55|zO32WINpL_|N%cbA8bz)t zwOKlh9LAU3GmH?XN+dEM^uG`7dO}8Zio_q-y6hv)|X-n)KENgz{KZr4K)IEROO{yAl1Dh(Ul1s=mhi z|5mGTev?SsgV#qrbt0aBbpYpcgRjxdb95Hj+8YbTUMfVAqF-@R;UbrZgi01h)8^GFnX|C;t4QWx+?NR=b2joFzR|QYWu`Q1^~{#j*T0a85{HqmscDzU!Q1+-ejKCwqWB-M z-IKuz=mbZp!VTlp;f8U5w2>thfPE6sx^fC2bj|I)>8t)}D}GvXV-Y{sH|*-FScH)vU*X#7}4?32bDs!_g6(i>j1CmK0K{?*Ehw09Q`K?CEbf2z`&1rSuNhsA=YEb@iI2$7L> zhPltS?|FtlQWzmX^wF_8Xapb1x54T5Y$lETCG;Bt4BOt2_4@QxA6kKvC+I*jjyc6y znh2$hsGbM}i6jX#;3tCY=D}6^@}#`SmpYmqS!u_u(P+#fgw~6Wt&6-VY2ggLF=M6G zbrv~?k7etdLB~SfH$Sa-LG$q7=%&_9dWS}CvlU}tZ;IB9GAkj;ad6_VKKpB0ED zVXGQT*_U?1vDz7*9Xm4?CApx%lp|L|jix$_2@tDuoh8WyIUZg+;mo}+K5+l(`txug ze?XB=HLoV&riybvbj@9u(2c*^jlaR2YE+jD;VFUTNp?e6L2*3vH(((J0FP zsYC|akX?lO!?er{hw-d*(+EfbjHW4o)TdRQBtSScbd?qg{SX@j{lLqw+O4_L-d@&y zd3{E;#KRYLdZQMZ1y`I&XjAs_HFrieobfP!6v!qS+?k_G7>OKblTtPOb2g@$BNYoq zstZVht9|;p$okzT*XfCD)(LyTTctC1ZtsxPHS?Xeuj+Q@(nmjoTt}eC#i(p&q1Opf z1kP+Tm_YHfq$x89MVl!?Zz+-G3!pG^H3hvIf*5)5{n3B_b8rpsdf---;mfDGkUooP zB_O`ms-6o?r3#&$4$@Z(#zKUbE!|t1==A{j1FU5(XT_2X9Fj-@gZJ3W!%J`f;?V}U z*O_@|DwF8N?Z5r;?yx=6hU(0FSg=dfyemertTI@>MDn#tWV3-}Qb4y?!A!(TucRj2 z=-xQ*TI9)%$b_5%yc8?05@!G9GxyS?tnvfR!0a5G=O~3VudLA^fbBd{vSVJ!wQ@@L zc$KVxl$Zod*>ingn7uaj9Zqz6P7|DFmrTy49C6WdCY4jPe2Ssj|L=r4OeVz-;h$u> zcB>_7<1xS|T9yq=LiD0Lh8|zI?laU319^c9TOpnJ!Sz*OsU(y@qEHs3_(f-VJwB+R z9xK&da;A7wpSm)N(-tIyw+d&*EIQTc#NfP*2leUbQNcop6AW}^5L}bL+ zKXHC;QjH8=DkEg;k~8VCy1!j_BVW6!5lW&XM7kZ<)9vV;0>9;pm!iQGobAL|Fp!1F zJ`APw{A7a%)t6+lr8#r7vXs7#RYlPVzMKImfXSSoBRJhofPEv5y59M1VpZ=j?WJ%Gp<^KGp!) zU=k+=TQzMpgt&_PYPK&Mo%;}f6tHZ;6fZ)#5Ne<`HhA)b4#ETTUBre+5UYR_!~uQ~ zR+4)pgET_Ef_;rfNDBkU_oolazkYDTysz+JoQ-EWrx;l}uFK!Y3)Y!8_vH6S@|LJp z?AHyG>OfQ^8JAwp0Ad`wW`VUln6zWdZNt8OHO+@Vhu(4iD{_PPv6UYfe8BIED_ea} zc5+nI5dNOB9%1(k2k4Pbgq5TUzzkR=TW|OTf`&PYEK!n>#mkXMSzdPzY^L#7AL>^3 zj&p60S2o}W6`@FAgm72n4b7W=KUZ4K-)PTUGQyYL$O&NjQVu~N5#!{K0pZV9lA8$+ zs%z-HE7JBy(+-?avbY=gy-bPdyq8u@wiX1d z$q=yVl}1K1jQGBVWh`#6sFF5PF(}?w-4^gZwnopxy{{~UyUW@?Gvio`VJ`ls%37s{ zQifQjV|fYAM}V=7kuWI%03m$j6eX;oJ()114zU89M~D15{f*a_;*!Ny-4!JH?k@8q zKijwPaCiPfpe~n6aSlSsX0Wr+bai5H902|yhnMDlMnip5m;cd{r#@{zb@m9{l~;1( zSDjYux74H|Ni~Gd70r(PQugeVXlPVMku0x*s)}gDm{WBH6D9#Fr$G@Z5UEIHTp;=* ztlE`}7Iyw|$oikL7uZW|alo-xohuHtJ@?C&Cy+DR^B0(X&jB%iy0Ls@T?6@M4Cx~{ zPR3z<+TvGGpo^5k1+~b2{%FtonWwwpY1s`aW=wYMp%*5ucUu zhLsq4qeUrJ$!HKo3crx)DJsZjSq)@0YGjsZind237b}W4kFrbZ6k=RIn{OYFb z;+l^+CMOQ4Oq{Yx6(Mvlb3`5S4Eqh^T9nR_1ri0!)0<=q3G3Rc3lFA;ved$v&i-8qG-K3JE@DptJS3xH!FRx;|EV7>&s}y z{FfBANZH=M%Wu8A9nn7poV3Oip+m#}#MWzLr5ON%6KEw%IR*;GJG})Cx83FE84lU5 z94@@+TVN+V*ygS#vzydMQjPp$CLy(A>APL8ANTSqo#DFNGCid2dcBTP1maV3u=%1Q z7b1kd$F?u(p7+p8Z~rg4szou0hKNRnU(y{;{@&yw0JAU+0b?HyVHvF z+#nO{@-gfKn6r#;o;+E&`eakwCS>aNQ9{_NQ|j`%Y(9Vz*#Log}Gxe-FCS|RYIfzE5~VWn+W3Y7 zHEx{6Qc(e|3qbf>8r)^~+!~oL%EH>*6T#{-l57&PkC~dSnRoARgE(=DU4m!{?9`}~ zG7cmMn}mfY(NNWZxMb)(222WW|AqITP26$eiF=Wn+xf3zYczxrLQX~PBQf`H*f~!- zh!91cK}!PaOJdB$!4DVB0jRCl0UI4H&S8ZZDkqQ+xBx)~(V;T8Ij|tQU4(NdxCShV z&c>qXxIVDOF5(pAlyy2g`O4joB=ZN|c+1QHtS&$$+X$)37+kKx*0;df4-i;Lj>hDb z+ZVa|zPb%n`04xy?&B@q=a+JW1e%20V|{+yP+rS%HSa@v{>~*!pSSmvVwemb!^)vC zJ~XthngQ}GAIz-4`^-<*!;{4$YG49EGP)d@sbVipW~$Mg*AVh5mgWkNJk@0uA4+9N z>8cCM)k#cN3UDH4aNRK?aXnBZiwZ>`kdXiELwJ~HpkX>7OE7`PuEASvpXvHV^Z9jT z%$`)4LD&amlf3QkU1guQp|^f)8i8|m$Hn#Pn_%mm zUv^J46RRf(6B5Ce1wCwAZQBhmzWsV44y)COlt|m)degps5G`vX`Fm_h5y0E96i^Ew z-CMFfl^o(vKX=tV5sOc`a2yI$M1^~){yY3Wli)hmzeDVd;6#*o8{0@GzXa~wr(e;U-$h%qW7b>GbO_iUPVYynbfl<8;^^0%L# zwqZg-QYoh{FNjLEql5re180DZ`e8hz$Q-zQ#3ZMqkb7uEk-2EH+_1^=1!a?n=|TZY z4#G%IfMcZj#`f!HoY{1|E+^z_-l_|0a9}q6R1okvMoi)1DZju!-~>eo1;<+T`lPs( zKZ`$6CWsuB1S$bckm02HB@}QIuIAh{GFU#eb6WDxSB<_G=Lhp%kys?M;8%exx|tQipQ z5fpUmim zpG3|i;?HZ7Q?k~#Eo%LG7B?Wp&D`>-7cVa zP)J5&2&{%%HX(rmTEN#W&qy9_nPQi14rubgp}@YIgnLIsZ0ver=azf;BV`LEnm#5- zhEgXrE=>SRLEAftTc?g(_@xXOiyM6@pEA7GQd_p@&EK}% zv-w^OSJKQ?Fj+*dgBkAoMk;;$-% z$S%~7A%Flp=<@l%ch16b__?7uvV&EsN>3O5LKqCI#9R^%*VRBkIaAm6R^Vm)<1^ze3Mi1A{3n(SHXo zJq8AqU=ol})av09Oj)#OSjR0NJU&`~q~fWdXb7s9Mhnys^*R`Fyh?!MxhY?E{btFF za%Gk7xSMd2@G?S}+U3?~oo_yUHyXf|&4v22v#D4`C7G(FhQoXi3jrx$nF=}Kd_6~J zlI@1fBRkABt0~NimI?MO>CT$Iy|oH+KEM;!$@`{m`EA*7IQ3ZH(y{AiZr4%#D0Ctk z#6ur_0npH(qCf;MIN^ODZa4|-Dk*Mr!{`OVGcPr^;>xOtA5>Fd5+2-s#rS6%57>@6 ze(*tzD4e18cXfH27zowKapfwKd`!QB`2IJ%CIjl=fg6W|qakW~myO?ST(i1!cm5<` zxpRDlO3Y`(Izpso*$QtZvCRZWH>Q1!KVN!$#}pip*7Jg?P?+lATjJ^b{07$PowW+NDM8&e1tDl>)XQS?{n#XXa)>^~}RB^1=nd|bwQYR@N?3{K4#wRIt z2!Y~M;AuO7c20%rgi2^YUsYs4o)iUrB&Ud#R6^`SkvtON$I|l?NJZn6%qS^4g#^?l zh$3jLj(o`vDZ)N*)b!n%v#6`Te^=yTb-)w$IzpHe>3MPQsN~coy1l;iQca-$moYMU zegPXv#(xIfG(d%R1uqtB)p^%I{&qBoz%c^oxUtwCyRyakVgcLKOiJq8?Hk|Zh#}{4?GY5FfbC10x9=U zgGCt#LrH2Z6R0i?hFv{1zw&EjTaz%a!n^YL;}1Nsl%~kufG&8xlA}iY$-|6{Vb!L(*07Ko=mha5Z z%JZ7bd){+4<(a>J#`6<>B>ekiVb~-rS+srUuIsjReoc4GNWf00RctgG!Qlh+Ezle2 zIiz;D!fk2=F><)VLW0_SL7@gDAt5-_AX6P`Kz?o5&^dcv{k;VayE@cVJr)td(h*Ik z`SYeV&(|4t1}_W8&1jn?Cw}NCE0OzsQ03asJhnX1fl@1)lWEoibK9a=ui3Sz)CVS3 zXAbz`$-ngT&A+W{@o7B~;X{P0C*UM9s&Kt8jU4~Z3lZr1&tcYGB zyEW`__NS*`T00YoKy$Ww^i0Ati$2?wGcu#^Dc#Y#^pY6Lt^dA#$x>u72b`N0uoH}P zdOej$bZUOXiK{6*J3{)zbzPe_kMNNS-lv$wrds=yHDI42vb?dGCXDpf`{sVv>WQ0& zeu?X+pCy<9)g18bh2eDhmAnc}_v(dTgaVXGPZ zMF;wIdVA;_XcubFU*NF^=wr|*e-)^V&)} zTEo2Ey@iF^*{{UZu~hN_{&_9gW)nc3s|O` zGu!ZVhGPq&eMPZf9z=nA@<~!3V^XbCJvf*=A=z$@A!0G`3pgJz`;-4r6@4N`qJ@zL zkO2Q@xAv40@?SVmx_5YQRPe4;O^sUE!N>BHb=ffEvGboiQIE4|&|0DDDjN(vJ6tg8 zuo%UP7dQbZnV$S+G2M~rb|%1eK3)c_oSjD^Tl6 z043+CFJo3knD6%@pJC7hjt;iCl~g{8tG1VX@Zjpanuc6O(^p<`BTj@V8C)5Lzb21z3Q+`*zGZsHkeu;%`i{55E)QZju7vzFFN-glYZ~aMqr_3GOrY`?cHB+mouJls<_t?$VW#iV>YdhybH~$7@GI``U z9n@%lcHd}6>6m8I$h2}PAF!xIF2g9+C$pIE z810mb$e}``s4G$BjNA_|9eZ-ieVGq8>dyxwXsPolgVkxsQ~I@liNT4+VF7HBr+|80 z?^%^TdDp&=uff5O=)r$cH47%;xg?^f4N4#X-zmQDH|c>k8xaL3&A1m_y;~Ap1s)ao?;N&)WR;^O4EDg zl%`vY6AGgwD>=tOu?>oxg>Q%jOJ3mLit5T6uqzX%yb+gC(;>_b$D$r98K%6jA2amS zi&jaJ5(#P(_t68;Plb2zDlU@QXlvy2dm1ddzMtr?bDQOqHYa7q}+Fa%>QTFw9zzV}lZE7yHQSARz!=L(IS|PkufGV*&gK zZ7EW=Lu!zcIla%HpP$CDt=zw{t*pWHwoRYQAFJ8gs%$SH{G?sWN@|Ef*>IAgOr5d1%AHEtbqrkNhpsj`@7lQ*{`kEq5FTjwM6H*Jq`dXllPVwlCw;5 z*s;WK0)`>1ICl5C2{+EQ-~nWGBASGq+XtGLf7PbYqtn}PG8kyq9-Q7F+~<koLhuW@KO+sk^t|}6%kfYGscMWztCBWw^rMJ#Y+aY!SCH;(=J z)%73k*k7o_14^B~s>?+d2v49}OPmx3HJ&|iOnM69;_;IR4%rg0s``mlf#hz*zx&;D z_x*Ooa-`UZYu_mAG(G8&cmI4!LoXbPRWssIY!J~JPw+xySWrT9NF6**epNIFB8bw? zW=g>tccwIC(wT;L9{3f{aQXaE&xA>Mv*Io5Tg@7H-`4c(GKe)78|oFM4)uzKjG^jk zfV)S`pW`3(!9soDY=)VbsjHP+pqLX~-=ZbWQA`bd$pv7wf-T6C3Gw#MG5R9#wlQzK z_>tq0ImmqpI6b^o*2|vl>-`PK5B)TmKT(7-a{c(BCBuenQ5(T=CQZUSi@uu@J9ELe$Xo$) z3Cu<83Zc?|ZAAqx;*MeqAZ7sJCTDjC0K9ofdJu6J`P1)?9@uEvAIRrR@B?QWg_L)< zpIp}==Ff&x_>(|B&){f}dcrYN8~7Qinfl;hgCcem!%C$g0t7If7?*ZPM2eDcMg9pBzCXfCqF8|dxkbSpjjsG?wP zdAsJL2kZ1GmD*v*!pj<)7nS32#f~7oyZAIX~)IV&- z)cJhtskgqm9|==uOCwVaP%;EZcR-*K7P51Wg$J2g$O)1Ascji;C)0&;jE>u2iwS z*SHS33x2~9#};`UNBrZ8pW09D{9zeJ^aSk_M*TDnlGH;V3wF}-0VH3onVgW3k`S>- zJi2kj(G`qi#?LC_=*$Ev7i0i{lHJ@J{?`k*hFtWi;y=72ammZ?U$v)UrE&6h%N^4iX8s0 zoZB*H=8D?4BKHqd&#X*Tb< zw6+7j(V6{AZhQj4nZbAkd-;gPgkfpIJc@~uIf`bJ5X%XP5>_%w#3WTp3GD2w{$7C5 z3d-=3pkYW}0e4PyQ$9_?=aFAIiz7bXJV{ZHm}n@2HP8pgY77LnLCBr`*AEs?wM6&DjvLu#PIj^Uy(#)+%XHm&8BCW}=!M17 zU(`X}AnZ{)QF0GTP>dCLbm$*Dqa8OSq4{1w+W1e)c9sa?n~LN$Z^ewg0;9u}*fkKM zm;hxM@TbPPAUJiPr&GfQBnpuXEP{<`202P1;0vRjr9P;o6C>Ta_PhJUu`8cMHv}>b zW>@01n%r-WjhcUIL)v}!=nf&lpvv`R4DRi*j~W7H@M8UWt^x_<0LIa_bhre-Mchg? zW^)xZvIXpJa8Bp{vf;)VvCD_!5H>=hc&jk@sqMx71MTV#+p0$$;jb`cM?&g<0ULsx zh&te4Nrs*OcEs)9`%ZOQ8qeQQ_$V+~M8}iHnaBdnLHo|KxZ<+h9+1J{=2Z>45BPJ_ zP4(5hf|Q`O8?Tl5_~F=H8=jus>w_`;QShQic`1POO1AJ zP9NLy{iJVRp1E1mQP_4;Y4tFDNhVNlg7J^xqBg()5p*DkH3p+0+qSf3x{HhQBtgQu zFciffxjh`WUQ1 zk+&cPE6D6lm$p@!JScO?hHvlPf=t-}Y2+<3WliBs#rDO!yB3%+94?4dpDUb$i}=Er zJ%Fy67={WUMzJ`s(EuJY_mgk_o;$1m4M+~geOz6L((Z~P6T3Gsfv)=Xyya*vFDutHqWbo*+RK5av-3hK|Z#1)` zgUzc@Q~3&aKNMS#dGJ17V~h8(#rxP+^}fOie^iXP_pLj>e&RF!RSJK?23Iu~E>-75 zD|Ph2k-06?o~QnIz5{3kf?&`o_T_r^PAI9I1DG_#08d)1hi&dD zdDpMra;SM(8(bwuwuuPg>d(1OjBlytZWU;`~>UciIXsF@ifuheK(m}9Djz{O* z-5kIFJ3Sx%_B#i_@sJliGmsy5Ee)(v_S$b7y%6J7R*EPI_SjhI;T5Kz zO9swB|Bzs$;YJ95bve>D|MazWv@tWlyaw7C1Ok#dkib-(3sK^Xg*3`p__C`#Sz7gM z(?`r__mm?`72pRx6*xtIEjm5y`B(2>mZq5^S}<0QmaOD3P(pZMaBZ@ci$P5JB!a;- za_`psTYvsmj(as4LX+@!*;U_f8|K-8qaAeklOtPib^XVz?8LlH8PPWej#Cgo>6uA| z*Fh35Jx|`@cjD3rUh!CPozok6GEPAPf#ruMPJJYSJ8;RVTAW^!@K41oq0#RvhU%&0 z8NUAkluT6&tRMj2_GgV zRL~L;M*I}0WijOerV(^4o`?eLCkR4xQwsl;Mt;02U!TNc?2Fjms^6ckTQ~ z5BN`Cf#CpOapKXciBoRH4+gC|T+ZM%*&XwKTBRd`G$rBXn$Gw1vn4J@A*MBT zDJnjV&aK}u^_}LoCUwFwH3rFxnE2qW+j?#Pst>1GIW@?@l4J?OLrcF&_gi!NB z|6AI$c;VPO{zzH!R8hXTtSaK@Q9)1g?m@y^c4-Q5A?YIPrbfCB7lbm(?v#2@{Jbc) zSNdz%VIw)Z=HkA8UB23TB#xdQlV}ez z9)d^0D>Bu3DMUajlcCF*!C@7;F|uHlFiWO^?|;|0M)W7BG@#<&2-#27Dl4Ye@mmgW zxTVMav$fm^Cg40U0f(q>8w_g@N>*ewR7)t@0S=&s{S;uASPJZtTI7eq?SSwi|Qs|sI(MBO-d@NzRx>36I7Z+{L zdfd?((<+org{(3k!IC4}UkE)sI6a94gaxJ;;jHQLX^_DKI30GO5a~%Qz5u9l16AF9 zVJ0q{iy>y&ezvdlQ_=m91rC%`QC;$!(j(1S10>YE;#;bst2m)4k+#+DVXMft`lkI(;xNiXp z8J&@1RV^}bv#$OZ&iy_1^iP`Eq`Set9ID8+7QN$8*9uq3ie>wZp{y2sB2rtSZlIx9 zs0lPQl2Dqpe$HI)=+y`$-T<{XoqzB># zBbJ$)4tVOXZe`nrdru34DKrT!cHHi|Ki3w8o`ci;O&Y*Lck_@0X<(?$wC=Xs;~Aal zgwTX+h9O7~pP`SZ?|!#@oBKNc6FDlP{wtTgIU#C~HqvL53yIHheVBxnU6)(Te;xD` z@JIc4%WS)>-X>@Zh7meO8R(GLn_md}f!7kvLJH{kvf2_7jD4X5rU^)~%JJuWeEw_Z z)L+-2#+dI=Ttnjuwn%qnt+4bGsPnZh7J;?t=S$D8Y z@svl63P}oTE1=8d$N*e*XF)C)`D1t)RuM6orJRDIlu=O>FqzvzjJ@=1-+^yqre9lj zX@Mi(m1XO}+JqFlm?xzdzIoKvyI zxDf4#-MV9Zu3wYatSz-66_`^+kIS28VJ{-la7b zAfnX*_OhxoGn+8|W761Ah9&kO$kAI$5?NLcoc2e{*V^sE!|57694LUOhb=5S*;>lr8*s|A|0{0Jixiih!PzaZ(G>5!6Nr0?I479e=uPR7$;Uj zi7JkW3*a6kpo7_vxJ?4UDX1X4<=_HSIB}lD|MA1&x6iNs zF6|k;fZ9}=AQ377msC#$@<8&5>IY$?u;sa&KC>B)bBCLBgau)^Nlt~s9a@}PKlEhs zvXpl)5lx6jmg6n%BPK!Yy5g2*J3rd`2w&Sz@i+d9fmL)t8;P;n^%>~v3vUadIfei0 zXsp4SXe^&58VggeGF0=5_f@wAypOHX^KkDg{9~TD`@|P>mKUMUAGGDOQP*fh91~P_ znvsb9*nZrFMzjz89r(t#_g2(->DpSjt)d=>EfSB!MF`d%3AbMt*KLZ4Gq*wXQrV$#%jv{0FdA6A~drFFv?--8F^d3pJz=9bES0hEg_zYp}&g*4~bB zrJ{|PFnKZ_Gk*}xndIk0(;DFnC|~jvK(Gy*3d8qgjNg*!c^!ukEl`7yWZvQsMz{W< z))fyoTb9f3x92Uh-ym$aafTN;9TNA+&)s>f?=5W}^o0VFM5w`5yh^ww1?mc3b5wz2$zOv8T$FKvq##iSiQa2=ir z0UTs#C9@I~D~d7C$0FE7W;T=OQm)&R2@RMi{my)lw|x~2C*+SUI{g5$brSNkilhi3 zwrg$6&_f^e&e9tbUq)!nPc%b924Lqyga=^nuo2W#l-MFb*D*sV>o3)QxkHUREW>h< z$ZHLVjGfr%(5dT-{y{TZ(6~_-9%bg#L}w1f{CP%=gL-QeNkZZfS&rbH4b*y;M`E^6 zqb?NT0aLEik(GzgS&rYAtU2_P)CDPvGoZ{QbUMC!!Y^ApO+x=-AZ?e!-4^6$6KPxl zODqQ06G7mTBLID3R8}5Xt?A)YWgR3!xcm4sf9+b~`sJi9pK!gpa+8W$hpoCY%Kt(~ z?NwP;hEk#!Q|kG;jV&u?8bC?(R?sx;X1nyu@rB7P>YiDJ{IJM?AMU>J)UEe-d_LlJ zy+I;O8b$;kIm7-7nVe9-ilSf;pfAYiZ1=8jY?IgK*TNwfWiSLLq4R}4jYm|JFUPd6 zZv0JpqLV?;2)@J>K({xm$^&4wk{CULX$KBDa9NP@v_$1|W>0ywQIc;`t6y=eS36qN z*GO$0{=p=4-*Kqtx6O86^8mjSxN?c<8-1&K`x!fs0tz<4oPm^Ku_yQGAq|R8OOChq z=4LJ<$3G2+2{e0&0O3k@@Jtt|vZZ4C>r<{?T^DW5A(ZQ$7Z&}#t?1d+!+1Y}WKhoi zy2xpWwQlh{0D25~&XVrP1*qskXBNP}KWv{n8E|STmSLI=bp%uD5M7R0598^bQBb}e zYN->mLkw$R;1qZYHrg6F44^1;91s*~1JgEb`Sl@3$@U&opIL@ zpE&OIeEuYuPAvCqRFs~fJLl?|ul#Y{`!`ii?trdMYfT;BWZ*Jg zaxbyjj);tb6|h1ciZlkedPianA$?+=bKql}7V5>OF|!ug?TpVvqJog!J^(kBO^MFg z#`ZrB6iAOi*po3Ynfw*`DZQ=AP;+2Xm^eVX!BnsO(BOKJIIqZd$c=cNzT?L~-8)A<2(QcREzL0=l%Om|K@KIJ+K?{b|6$_2hh|^77dzGyd&FD0 zV~f8yFy`q=8xXoC*jD)R6W$utRrCSG~h+9vfM!Q6#z{1pr&Av~ZNBCys3KqbVIdH@6-VNku4 z)xT_fU#=m9&>5(l9KfGfwMb2bka3}A!#OdlTff8KXfIPk)#1>*Pq+bCb4-y7^cR@3 z@VJ07eppfzrW2Fzt@6?UaBJ}MkCtA^99Db(`=>4-1JyDZi;NwwCcN{{@E5R9;eXy( ztiM&zWGi)bO2~E6NIOC0T1i0k|JpX3sId)?(b$I3UEEJKiFjXiTfqC+8a)s9zOrzJ zOib+Y%DR*-dJqnfT*h@NLrVl-&4KtLv4bE9lGFwooCk-B4{#pAIY>Mv!5AYpFjlxB zzGnFidEWi^zU4x`mTRl?z96YXq=X4mZ*4jXC3$6q6O$rtjK;B5Kq;W{W;5{~$U(tF z6ltDDmZu=cmAh=^^Bs1_7t6`+#sL^ZrLFCrUK=f<1rDwJJTHye3XS$aJzzr^BQUMm zVDO5ZY72Hq!?Y?WIu@dX5HpczDn(f|VgQr~mRlUI)>i~*0EG@vxUviBs&a)$fDo?@$$%e%q=r!!j=1GWh! zmsDl5(%GjVW5}wh@Pmo3I9oV55yHqFgOkc1c=qcV{87;4R3#T8mS#?Z_Cf>Sh%3m9 zcL;nT9bwWnjV4S3ekfX@I_1Gbi=xCztIz(L*7)foU*b|w+i|crBNtzYS-SV;o(p+j z6sreyE0Dy+5XuNp2#b*~&8lD`>B!eXDhP=cBGRM2fVKbLk(1V*eEl5SO`78zsaou0 zgpj#IykXC*V~0_736d;RDPTD1sAjC0RiTJ(Y~0kW!ycf1sYDNot^!j6;+c&?tOV>6V4xxM8Nw&7 z5iUzqImvr;p>7h!r@H#zI`qj`@vO zeNxk*>x1L+QV4G^tJE9~m70BiG0N*KgaVkfEZ7$fQol`U{UZ`^vx--hnapi{_~qu~ z_s+uDA7v&DjF5`I9wMVai7(0rSuab7gb3QQ*&BZbuP|V-sO}E}+JBx&BccF|}9E92OzCF8qD<+7V4UqXi+bhdc?uSXIzl zu5hkIDfQeHfUFp4)92SD4QRTn4-UJuAy`zwVRtQl_vfCqxfBhefsqlYJpWw%q}ZK+N#Bv<4{1N-JW;pLuU|E29}w7Cm;7Kae8 z@s#4!%19R`!E?ORiaH0z{CJ0USRph75{=^rWyZQ~gOf-1l`L)#aVn531y2dY9KvO; z(;EfJ+txb!Pj;{Q=LsA@Y_-4VJ^oDMpv~Wy(9#ri*pt!GGkV1`EC4@>BjmmC0v<4w zo$bY1EkQTFwlv5ZtAGCMi;H%%S2|br?V?C$d^(Of&H;`Ew#e8f!PmOuvYP+gwR$2S zHf6Pu1Bq;9q{DGN-HzTVUZ=wsFG1FrH`{3|^n%IF?5*`;YMYvR2^ZthM<;gd` zjLd8#znTR9#Me95YWvw;7;zLdfmM;lb%k$;`Hdyk7e_862}Kc40}Bg?8vrQbGz1D@ zCgG(Q*G}v3;E6)n0%SyQgizG=^ygWV{M8PH&8mRqNKzw^X8gi2dxRhWzqBq!K1r}j8$tVez|`m&_cm`feWhW_?1@;eB<52_wxHocuQ?dVIa%^mH#5bOcY4x zu`<9+BTmal1}(oGc7xv&_8+KT#4(Ey#!A*TjoarP{D!}w@Gv>q&_JlsPC}U@D5L18 zj>KCHNw|J1K@1>klKjHIi>(jU)-DaU{@B)QyX<@J_Fq2J3=`X{m7&rT1GFAISQSwJ z@82nKPf%2X@ zk8QoiLL;{?L;VAYoE`1(0=O|4BjVD?WeQxz0K>R)O8ejZea77T`rnR+>j^#$*dlu) zUz>#S$Cv*x_iFpHWBgH|#CFMDoqPpU(LhCx-0-*ufo!0j2umQ#A$9Z2MbcFtZTzNH zaf>@p_&|4;x>b)?gfL<8fyd%AckgQc|3P7dF{$3r(+pzKLXwA*AgCK)D)ans=vtCA zQo_|Zq`XB=oN%G(!6U;z{Xt(@j-y5{(dvlL9yQvWlm(@NEcECjo*=&~-zi7D!@2-4 z+ukH6oLD~gy?V>1cYgGlT*)3622z1PA0d=UUAm9>BKP-a`6JZ^@8!O#f7|*FhrVnn zuS9a7cJyd!WVeGiAR(IG0Nc)-)h~~~rEtg1xCbrUil10tu#;ud(wvT`Pvz-_Ced?- zoHekxG^bdAe5K%<04S-~<e&7#jb^(wf<(pdd3x(+Z>Lpx=*k`2?q%=5mF%B^r2~hfF%t@XiCj z%D^A!=v5C@4PkccFLRtZ4f2vTLq%M!2%HgWHL)PrVlT*-0G39#K}(OscoJVikfU=3 ze)Pe2^$Ygl{%d3tm_0Fb!MbCohNHJ6Kz0ZXcfbl8!0-OMXwRZP+Vj*K*+8WsxAAeq z%h?wW|GEE}X2NcMU+IR-dU}FokcdO3-bhqpzJ!1j6sXJqst;K6fkOdmwSa^G!eI2~ zp^?EdkC?0$dJfrKZWrK z`l?08j?E&s`1Y;ALHG+fS2G$ zt3$s^JDJs?_4A@165LvI!z*sQ(4as;I&$Xs^PKK=!`t}xhxuuzb-#<@_tpBh)LpgH zM_E?Xz6%%};G;iyvav@+|AR3VENlkQ-;=gnh&7D|-K5D(<_$WwZqbyEj>ARm&sA;} z()VvxS@9J9=amBFlU+$yKvev?R?S__mbNvmM!yaH-7^{Z1I&x_+`hQwt(aBfclq3$&4yX}#x>g*e~DtN`1=xm_h#oESM{M$?zoZHIL__tY`gGS= z>`}YN!{(_yoJ8ZF56^#cQWoudWxCI(x>x*PyUrH%t&r^qt+FXSWr#)5DkL+Bh+BQM zbjmzG)Nk!|7xvaYbd0{W*BwEx9mJ#iE}Q;wWaHW?)T>J+?VBdLFWf%xw@8s}=9Wja zDifufiB=`zSL#DE7kT&SC+feSc(wN##@}PmVJlU1mq_%`&Uzeb=cS$9!7r$%_DMsx z`iX5bGVlSZN2!k~EB8+ke-+5Y-^VVq*dB56^b%jy{sP+aowPFy;zrb6d|Nw4Lj8Cg zFmbC%n<;Hp(=A)dz%6TPviw)J=e{3j=BEwvw3Qs2t>|JQ#{bOhGr66YH~})AIO%lA z+G!*_wCx7k=kk!yBMojo+_k4*&w^sDwg~o;NE^I_{a;57X^FCy%Kx&Y`+IVe718JI zOMcDcbxq9t^YPy*#3hlp8rrwrgX(KLM;w|Z?LMwc=^hKJoskKj*?%8E;M~=Y&dRB4 zPq5)#er1+wPs)>_Q0LW97d+-8L&M z=CnC+J0Rsk9(^Cav7$IJSk-_%I@4Ip-e<2Fn1OY1)GRnZRk4AoAC;N0EHr@QVP zniW0I*uSoGFo=FT={Yz4A`(*zr_4IeMA9b)t^T$1x& zIf0t~ErX*~XZ2TYlJHmh^Y4>{r)q7dmikWI>xO-!GPV`^)6GsV??ig!(w)rIWMz26 z^|McW3Nx?+TfFuq_|)+q+6m*Sou`R*!svgF-zr-r_#dB}$JAuiuS!L86+V}KtN8uv z32M*%|H>va{bdI98|krWty$=w+wd*B{c+9EPJbS4$gdgdpdA^fx@M@8bj?s}?V6#w z(~8nXL+O>cfcRw+qx`o|X0m3`nk@Tv_DNY8U+o7#>W;pbD!1{*$ zD$;Wa?NO9}ku@H-GHj3i-ii(|A1nemG!f5U#t&h)?WMbZUy$zXAKKAgmi2r(1&fU( zHu{QghE}un(49=Linh9eApzPdTUs^~KWg9Ua@NY}O`Sd0FUU|mgIEJvqZEAO1^ogh zGw5+D9Lh}Z6I7{vA*im-tQl{D1J#--Fb-&oGb@NyoPufK3$HD{_23*eJ^Zrr4kc9b}d2o zJvZqOK)3ih3sc+VuWrBWBkElQ{~h z1pBt$>NhC=-MgCj!Vd7qM(Dtxf4T?H)MV43z@K|PvyDundW%BGpQ|@S)AkhYE0n*t zr&wv%Rn$&js+~zsPjPIa_FgnpTpmI9cE|9^aQ@i|LGa9_ezTD99WUPSIa+D&b}Qnm ztJ;g0o$i#_y2Au?zN2=Si?enfQ>!K(<-IcQHlMqCCq0K1755M#-GS&HlguPCdb;oN zN;Nm+6Srtd5z&1FYZVeC-fI}X33PXPyvAtXOvO8YJi90M*%t55exDCWumAI>NzrW$ zqCY@_x6j5uGgQ*;;dIn4;$CD(>Ct`ORcuI4L>6?j3ev3`>9KZWV3dFJR>J@NhFZ6o zIVrE@2@Z#|)Q%d|ZgJh&#CrM#Xy;?Itf(ES;pMM=8$P6qMWbc4s;_a$MSuNF;_V2L zR+HAx)MRs9itZyl55K1aO#b-m|NZ%4|KjhCsQUJ|>*TFn#6WlHG;IgFwYEcDf6vgK zRh#O+t)!iVKsy3Mcei7AIIXUI)-ZI&S^Wb?cX~WWt47-Y4Yj+q?kA(yb=EfTxQ1w_ zdbM)Xr`^PbzVD;$HS1xcKNL;>$TGUe z?caEAY~A{+HW}#u9NKQAZrwTsdh1U0s{a9BDb&vT;pcItL8WtD8gz;C?Ia`MRlp_gGPV zUez7gsd(_<^7Zs(*Wr1IaXfrSEbifW8;q#?VuEGhNE?N?K4vk-N~`E19#{E zGX33O`vsSOdi%U_gFa^T%tUu}`n)9H$fhPc26fByJiK^k`eH6WT8EBkGyFA+1p72~ zM@+_Fgi1S%Qhydb95xU+&~Ev2>o;@{m@GE`$dp$ynMqV!lUcqO>c;tq(jQNsy;|cL zLcO)*&xZ}33ytlk)<3$m!-@m7N28y&N2qp1Z*5<5&Xpsc>Nhuencp*v+hahnk7)+5p*YS*txOKXR3uzw~Bf8HhOTsBGA z_=Q`OHi3y7Q~iu<{PxA|VX1v{TE9ESEug1%!IPxk=!xFyHVz@$kwcCxJ)CuWBzkB+ zYD;oA+czZmTuA)xe?wbycSR5G{k8h!=ZzINmEmts;sdMph|r!;D(XMvHPs#ekKk$|C`gFOpyL^rY8I2I{$Q8yQK%MP%V+b?hu?F#_%(q?!BUZwdjmx zR#w^r)K9yLw*Ep0x{Dp?PSx8Z^v={A_ugk8SCU=^W5dD=CD{9|ad{$)F z9E)`}@wg_Z1dTMn2E2}c)7(XiEi;$HRNKjKf@H>Nv*jP9(`+F5=e;&*CVYM+sHXSod0 zzQ5U}Q;&cAM0zQDu*39nu`^St?x?NA*1x3PQ?0dAUu&-c+V(9QZPSvxEyw5>`Hfi6CRe*=3UCS;$fsKO1)-C-*TU#+pA0uDo)Q-IK@X()^hmLi2vgxuq^cc|>Thf9>(HiaB`<9~Lb_>h zaq&mB(Vx9ZTS09Li>0IPOitQvP3=~Khj;w#@qT8mcI6zih5(0n2gr{6du+KUuexJ3scHwXB zgRky`y6%-p``G`-H@NveYwc1G%6--j(mv||ZJ)I^hjv-hZ))h>{tb)G^ViNSa<`uN zjp=j=_)tP`91|Rjp!#Z|t!}S{xaOsY{%KQtUlS2C^OXDkgO6z=dS0;{+F2&#{~FLe zm1tF#htE{>=?f%wPtC)7Qffw zcFil*cW0QsYny5v;!l=iaO07UerK}w=12c&S$`%Z{hH9bEQ6;&V&@CDan>$@9x8U+ zDBe>Vx+HUg_W+BEw4WRjC?1(llJVX+hAweQ2UJ5I9Pv*Ol^C9Xo&iDTeq+C_i6Tf zdeUF>0R12qPOF#9PdjIveA6DWWhyD-@D@*Ovc7dTD-aei^wNu*l z4D{0f)|QoFYnMq+Y-hQlZ@51SU%K_Qd%rqE68z48`58NDCr;+COuF53IL74nx!bf& z#`+hYq@FF=)a0>8F>AXrhpW&xcKN-Et~p@*Fe01@6VE`lI3}aM?hp;_dV1mrjY_(= zdD;t6&!NM=d54U;O!uM%X5yAhaCds@(dzj5^>15F6_r2t>;A=eakSOIgEqm7CqEOi ztvCs??t4Vkl3;g`?m1BUrjDbVhy2YPLoYt`P&P*Nq`Ve*cBJ=!Gy6xn2&C0*Rb zB%kzBODk(?@+^AByDv-j?c9*yKCaub@!vh%#rTm`mfCBt?&Ncds|ih z{j-O38A~gi;7RwH(o@^R6X+4xNjtI0KReLQ)Z|6n_p$w!Z`_hcJX8ICTGZ{urFQ~G z&kpc^_AIJ+!c=XX!*Lik;-hK&X@r%hF3Tn!K7`-TC@%+UH@0=-cb}&MBw5Tm2u|vX*c^?tkQTR-W1>BJF4b?O$zcf;hHB+ay-W zGQlP>Ll?F%HF*>M!u7XqEeJEYwPkyrc9R2igRP_gi>M2&yDa5L2y-HzrEra?7x@(&Ov|V(eeY9_% zckk)bqmOoS9qlNNpa9)buR%S$e4Ik;g4|u|RQ3<^bkX)R>9V@BAD?f${6_Gc2k{s9 zp$#f82VcK^ywKK6oV-rzG#fsXS zbNfNbtL<>hwv%oY!w0nf_?7ki=M$Maj1tjWVtxPrv2)#OcM9z!_J}E8L3KxHBshRZ zyHHlb{a*j%2pZiJWS0bo-_h|bhA7|LeuT&EJv4Aw+P0$b`^}H;a7`=i6N;g&!D1_v zrFM0O9--I}th;0CJ_%}vt7#W?(`|R?+ei1E(N12W&Q-LpE8{q}eQmFg*tjff`~#sf zt&<=}2Wvmy5W)isVE-S1$0Ye5i~Vw_BVp zBT{TDE|4FESg{S;x}XRO94dq#e2aiB#k0r$Vmy~rwXHZ$?k&N!oA}0aoY<@yTn6fnSQ zTRVd#>%^DX4@ZSRn$C;MswO67>cQAppBL^lfOesMU%Z?^y-6fDq!C)ax`8d-`G^s8 zu&uD`(dhz&z9@7j+91c<4JtqBEljFbh#nNA#*MA%r=)Ru2jrYRz;}YweX=8d>emSz z=?NC_0{_*2pNcsaKI%ygebv4p_fi*LS>*@auPd0zA50%0a`<(kxrp7^PCZ*Wo=Rn+wB1Akv%b$wMo_@nxR9|b8LJ%D}! zI}hagpQ_S>{;tz}F!GCrfFp(_t$*`yp6fe;Ygwfq31-W4X>e4!Y5J z?%x$UWCHw#6M6mLr7lZzH&5b|w@!xcF^&7A0%zi<4}#>&d@>8p^Vz(zZ4TG6x;q!n z;Dun}aB#gKByWa{T150zAJ8Y`vNiV8(S|>W$o&)jClx z7s)I8g-U4T4}hHyf|Cw`RStvn?{}f+ z9U+JF;8E!M$G`!{!38IHPF6!s!l`@;ED<9oxW0ATyZSmAtLa6}SU`)?HpN za}RpA;PU&>Z6AO)1#>=vjuV9X{cqe8{CxWfGh5@Rw%?FXRAE zh*K1I$;tcf=HmLNIoGs2nGv){M=CVRi~cu)#lrfz1cSeb zBQ_nx0YJA(^1QV81Tsrmx8Z(qaWR=Qf;2B$9F};(j_3DPf&Nwv{9GLzMwjdm0|wI>l!UHSi_f9uWN_mC z8E39N;!kCYj%^}wNLd!jn(yf?(kijf}fj#lbWmZ{w=tl ztR>f(TXXHy2Kp#niJewR&_nDivG(A7QY>EP^F*$2{8z!^OUfU1#UFCO%Po8`=Yb%v zCR90tc$+^d7ACiw#lxWrwSMT29lEsHYYC2-1x< zo~OQ}Qm)e&<9!xmQC}cPbBHnHP(Lspygd=DJQ<`MG5-|qTg`wzDmY*!uTx+5S={%T z4ZU~{_bD&)%-p2q%h z{W0{@C*1$>lb`9m;8)HB-VmId75Za#@V+=haYRn&fcP^L(Hg2*GyZ~Qs9WbjznmT~jtt$J zUtOoXdjZtbSb&uag64(5;YC2o*DeZuPLO(K} zdSpeeeXY2DEoqups}geNwmeUDqNyF~zE!}sReAoMq^WOjHRLW<2e;SYeeY{RFRR6U z>L<=|Kz+6o_@xdQSrN&Z=uf7`~fYE*C{usb<%P_MDAuAy#sA@j>pEAo(MF)%_VdbKk5BbVfh$ogmHW)0O9Q`EyOV>jB(9*Ntn+ zeG7y?D@a|ZTw*K|%=?{saQ#u}jG^$S3fAe#b8fx3HniNny^$*(2KMTcv_6_Qqc6|b z=+Cuv{B=yI1KeQ1=PARg=|H|5lflrV1P2X)b{oob&4zPbbtKpF5@SVu)@b9o+hf#q zkFoI0#;NPHyv?G1WjxP)p1?KbmrPXqRG&Qw^|;C4*(u=esl2c1G_I+?)O7BDmUNa` zsK*LYU-dcg3(e#GR6i&DVd8+Nf(wwlCrG)k3wi(eMO<4fhAtEVZWFXz2K`*H%}Uj*eUqSV$}7uXViYnv)pfg zj%%8~A{M^?1zt~ck!#8meJ=5O&dbmluW-NJRj#Rj>ov7cb=T{tr@zT_TP02T2DgwK z9LMuiCpNi*dYZf7)_dTL`(XZuV4KI_uO}e&M?B@4{9n)DN525wUV=kjfvH}DlqV*C zqxPvztn?PSTY}`v9QaN>@5l%Ez8}GSpLj0IXXx>QG`IIxo}2iMYswL8eCPFMKcKVy z^Xk05QRt2};J*>1_2^oY=QBD$yE}rtop?QUZRpj`+^2amH`d{~`gOUc zeD!+p9|)4)t-d<{P57QJygsTSbaPkmX=7fexy1ZUP!D$pU7H!t4{VNl`hQaQqd_x0-tUC9f)Dd_A2ecYGlX*q8@!@tu74Dka~cIElg zlBRw`T-1&CmkH$hb`W&V?%-Cz(IL=hLwSBePp$)cacyWllK1Ah<&xeM#_PU)xR&QG z?u+`e0X$c1F!W79zah{Ihw|K%VO-1eWj%H{^8H4EPX#I0Z#18`bu8DE`&-r=hdC+6 z^LeHdxHdF5YGTrI%O@e{HJRtrP2rlB6F3$Ax@lm;>FV69ncS~6hijTgyd~inhni!h*bMt+{Nw}5^pc%>k8nZi8hRuuYpG42;D0sSfd zRM%L}>{2{O>rEU~hSvkiLEDuF-w9Hl*r+1vGc9>P)rsY-Q8%k(JeSi3_0xi$w$NAY zz(V%mDnXimuqu4gGT&EI*LPRv{?8g*KdlLUvljQKJ8(VKk!yMR)=sE<*9I#&gO+u8 z--UWy%X3Iis;|y1Z2YQbJ_*Vr-bl|!C9?%;EYjlDR@&q$`fs+K~lxebLvhGnlRmDCgG+|72HQ z{}90S_-@elLENW#(}UrAcL($L;JFx~+lIie-;>uvdO`o}&3&4`xexq_{dnDc0QB)e z;PAm<*&#efbE*$l`#naeed;sBuc9x-DBk~eH1y0d;DoWf?lKNK)dXJccrI)X*Td&>P5rU+;CG%6J`jAofagnv zL+4xs?h>Rq(-y-oyp;E)S_b`2kn(@aN6Y!#u`8g*ujIZwH|09xb;?f>xh3m)zQqQv zDNj5f$?Ll|Lx*qSey6R_Ew+J;xAXe2D6U`cfzBKaz7(Y8%AC3%Ip+gl#6gg9jSfR^ zKLWZP1;dW<9OVO!!(Va|oNx+E8>7y@68@z#sE3~Axh&^I|9S4y@`!%1>iW2gYCq2< z_!%#Q;es@enED#(^RBDsP>xvf26FBG#`NZ*$)b(1A z)qbTX+;@MGpZdBM;QlWQuIChlE>wv7)c>L|_oo%%nsUT~ zMb-7Z#ne9a$uuvH{0c#@61?BNB=k?gDW!P5LuszBN}86puMBd}%JTfR3ea^cfzdYL zn95*DTaf0+ykUp>uqwuL)E8^db7QJy(q3uZB8*x+eUywbb=d4)7x# z!QHiau8T9*@^bIg;q?^txTgF711C1>+d!SCKAFW_kY6t-*A40WuIO`X%$FDD#x?bK zbXWUSZ`K_3*Mj6Hl?z*_=jUyy_GxbZ)~N3gOy8F0=eOf}czdqrb>RA_2iMy=avkjn z9qa{KdGq>PU#v`R{_7CKGZV>dD?qK^6@M|c~?d}PEp%?f2_U4*yx3gi~ zpWlb;<^7;9^aqCz;B}faZXkTq!Qci#s>{4PR6U1svxgh6Q;s-r1kdLj$u;G+OMbR7 zJXc^G*VOm7%sf#&XS(pCCaLR@li^!W0c%eM3r`2<&H$^=1nc>Iv6CkaRL7qfzj3DJMoq`{FI%#w6 z#u(4dJHzYc&O+}Lj5-Hh?L5!X`pEQ-MXvpYq~(iULT;yE$II%z#|C^_ezz;=bGWAN zzhS_q{(d*qeI;+g_q_#{jRU_5Uc9aDYjsEM)A9_l@m=0G`5xC@A3*;Qto(@AY3|6! z@CQEu%RL3>zu@_*FQG@g;y%rhx%dsw)qV@@`404b&+A1$a82`$8}RdfLjJbkk zHD9%)l3tgZ z*A2}tmrk9#A^a;Dc|9r$zp@6eRO0o!HqfIhbAL(|=j51 zIsu?lH=d*A_6mewDF_@MtjQFv!P)}&TUfid?)VNPrRsyeX@cYv@AX&DrMk>J1JwEP1K}4N1iB99Ifo(8n}>q_!+5>*aIWR$HW-O| z%~8g4)c0gGa_7f@9mn#%N8`AjAx_NPZzA`{Pv$!J6zJ1axlhX_wwq?WPPr`8k*hHS zEH;z(-JZpD_u0@6bHLtnd7b7G3(Z4)v!Kg-<9X_nc}MhZTbQ)|xJByR=*93eMezDV zNz2RsS9SOjzP!aNpdD6%?yJEvYr*@1wA`NS;Fnqtl22^B0sg3s;KNPoT-7by|FV_q z)H|WWqPS1X$-YbN*WS(jD?*z^!~Y;ib6ofH{EP!!Q?Bbl_-2Q|riazJYDeHNKc=qJ zyjjOlUvZM>il65CfTXFv_Bozg9Sa?Lf%}Coa$V{YwAW=Y<_h@vD%k!8NXr?2lWX$F z-r|1WIOy58!7+Dvo%)E+@A3Mz`&?7b5HCF7`L++C3qRt%++Xzx>X!wn?)OyPH})C) zL(jqQFTi~-)p?pnJo^T@=I_+`6Yt@heFA3-Qva7P@Q-~{_qYAQ{fR%JLw|ueO;Xb+ zJ+Dfdif2rbJCO|ZOwRi#mmvlG8-ji*p>w6?`4y6`nTFRd2_2mleq=iEKzeX=2GBes zNXvhoiR%$rpz~zqerz^q*X*Ew4qm5u`OLWgASd*oT--05n``P%DtDNpe`+2uYkqLL zpggC10o0u>K)L=;b=iVRn-?i^?uFI)wMDppxhU6Tig6uM9J);j@LnnKL>aJESum-; zSMu^a|5WJh6}T_YYgQ5Ube5ov4bMAO=K7kX&)T9s#GdEmd>(@ zxo>Fh-}+}AF!!7zxZX*ly5>t`Ba;{ejJ) zJGKDt2##vWbGKVTd$s{vw&itNe%^NQleJgZDQAf7IvDS}mPnoEKJdVt5gkFhPT+M< z(AEb$>I+gI@m^=OPj#6SyC7f4&v;*Te_k)v4SJ2BJl8f5^{hd>k8&3b_+Nr~{(g7p zu|2?UA>aqWexW>1^G$ogAJGdu)*GxHrp{04qxP%zg}=QY_@zI1e*n+>4dR;CBiV57 zKa(`&h+Re?UwI@LFq-#MF5@`0Uuiu2)q<2yDnlorf5l|=e467l74`Gez+=#WHz{d4j406ou@wH#`(x?U#QOi3RnBopCLkBufGKTSwYGZ&n)GA1C~K& zUe0~W6IUcsH(9CfFS!c-R>5OypgXMvUDttC*Mqw@fVA9R8@cw4gnlYWxq@5Z*W1eT zR44jvLw)XcaL5ku@=owo6iE4*ySOIb5V!3{e)t}6!d`X%t!VC-JHWL(Kkq@*D;xqJ z9p?FaN4ci{Stlg_l%z%QiSWCgMtxcgIPMJSbq;(YNb}d8hhH@oB%iqC0{6#XNOQkF<=Xu@ z*OVg`eSv!Fm*9$5JYVW9bc=V~zb$E+N6hpA`Avf45Bwgbt-WG zhR{td;eQw0W5sj5t+`HFiECO9;t#1l%f@(~`i@jaZm}I`S;cr?UVC1@A$0qy@XJ@@ z^;R{wrsWc=*W&f!(gg@tN}BqbJMupAi#TzAtE4Hn%^A6Bb-~W{cpv3tc5Z-NW*45f zX~^{$SLnb-+?VH_YOJp3Yr_2u?p!Zz3jMViII=mf%gaej4{w3~S*^g&hHR@vmkZd(7d6+JYS+a*M|BIh}?z{o}V5H9nljk*9*MZ8@wF` z(%hMSp{@FHpXwb3!2c>pK5@c8)ZGX1{=mV|UxtGFhJ!Um@*K^1JzDKkeZyE@-!LA! z(**9Pn#gs(NnE#_%r(t_I7RJ0nhL-2banle@Vm}Hz2r>ruprGRj+lk|%h`P1xjE1W z=5n9wp&ie1U!FsH-#O&GV!@mj!P9~pFG1J53jPwL{=_)!8u|uY z2YcNDsc&o?*I90Jy-nyWcj4a>q<%wucMtgv5BNMezw@EGzVk8ne?5gh{EYiFZ_^9z zS9lE__lEn&-a>o4<37!i+5IEWrT@&e*%xTvuVANdyiW7_e23rhC$D!jNlOtuADD7| zDjD?l5!w4DB#;YVZv&9d>_Vo6gU z@l!r>pRK1AFM^Rl$kXc%Ax)Cu^X-xF*=N z7FfYi-B-j3e%sn$$-3$s&2L>#UH@jlr#_i+_0@AI=jwub--bMwxiR!9!Om{b`h9d%Ch74Z zyiR?2dvSkyZ?5gbpu6?~KMIcS3*EmTm~{Y{Z6HYV4KY&6)g6Ss;K5*lp?r?nFz5!u zxli+-3xC20)XheMuSSDa$Eo{fkB7fx0=R4<7(0pQzfb0xmV0uF+8;F){)TD1zGgaf z*BRWWdG<58pJo=$%>w3A)5) zFh($V8_&gVhYsBV?%oM*i{d$2-@oO_U6_;p0H1f`5VXS)?i-r_`lveh;+Wc}Ipt9d8?|DjHA9Pyn?}}0TtIlx0?OABYb70Ez;2c3(zv;2Oum44^Dc9jL{7hHW_4|@P z`WkZWuJgRx4d}r)!IW{}azR>N<~zKPeBzHp>Xefic8|~Xybqn>0r#stgueP19P$J# z^AybV9F*tF+U5mvk6wdg-+*P_g68kQ-S0uUzsM)G|4sO3KCA1VU%5Z@8?^He@X$|Q zmzUf97wS(0<+{0PI%Z`~25pxdd@smCny8i%_428B|H0H;%YET#c)dzmu6w3~&YuA+ zor%}wdAk#-yJa=re@E0mWHX+tnFIAVg7SKNFf-n7n+x@Qf^t7;S99ZYw&p?IDKF0* zlXQoCy#7hjAq7x>V!?B?9z?T3s4o{JpIE1`y5F@J_gfd|+P4JP7NwvIl;%Dy$E6JX z!DT_aa$xH6JbzEp)GyP&0{YTb*$CHNabflWIcKdO6mDz9UHfWe1*X=LqdzoBNa}wsSUKryQ|$9iHD>mut$&Tu>jm zCk=Rhp$l|WL+;D{vi|0Z{PRY}`(89geXSeMjc>xWJinwn>J6Il+yzOuY{Ba^=YjAW zwBq$+t+}TBs5ad1(3Wd259q?3xIfg3>%QL5nSH=5g0!4%o#Ef_0#@q^QvHBG*C7GW zW4m#m@+$)2dj^5;yYpPO5U#1OT&UVF)eHVkLCQDo&GXKEpd0rE4++-m&vVx$P4kWp z;JKp%xu%@oAnxZG%r)hRzY?i89?JXg34Lxj{MsXVo#xt%Qu{umxj%IbbjPt^qjBKQ z@jQ2O0@t*h*okU?=Op-XlfhwA)VZ}&;rmVpU1q3rv^?U6L~`S2s^<)u#r;9Eq07w$ z_X`$Uz;la*j$O!oS|8%caMU|322CTtaf0cVsQYs)g}+fSW;yh#73w@K@4`ysb;`-C zwFZ5A1?4*F!E2E#v5qgtem(ScLCR0uz;hNGp;K+*KIMrMMSW_d@!X!xs2|(Lb4#{! zZNC%RK8pKicS9fE!+lzh1^eL7-LI}w&Jdjsp>Ne;F!ND9XTGFqPWKZ$M}EGO+nx=eBCLxR*FQHtmKm*$#s z9m;b5a5?CSmf&t{uy!S$Gq>TI<}I!a-`WnmT}7Q6V6XORPE=LYU8;cxtMmNc8eCJK zeJ$=^mo(*w)tz{reCyiWcdi57w=S5z9$2zI&sjBqKIg)Hnk%zgL*qF!S6-hf=>m;V zztb3e>jt)V=Y7`ApxZa+zIh9-Q?`VT6qMK3wiVCIb<$5nu3{UW50|uCTh#Zp<2jl` zJlP&~4-cN(?+HD|3-tE}Yxwfq5usOh=043QTKn<(9!XQq5X<`WemNHufO>Q{b>>bjxz$=V0`GlG=!=nH>N zKd@_maMA#9%|MXy?FK>L6bu{8>y!%^!u{8hrd(n?J(SPsJe+Go{q7@>yCmp73i|VC z%|vyP3zMm$5pjYb8}or z-RuTvdkZwb4c-t8y#syxE=c{vj`!eiy05Mud%*p%kGQ5e#6pkN^}r|aGra)k36^^W zo#8d_8~%>#+wZxi<(>WjfAmLQpZp2B-)GS53$IhZA@=;r^Qpc;r~J-+>c8~^{()cM zI+G0g(lApnS2B?D#62nC4^64A{}lehRJ@)m4fJQh`ssQ7gru8f;B{I)@mC^s${oz8 zo-;i&_s3-6x@%Uh^Ja%WF1R`euha6Ho58Q1lh;$^=9=<`81a{Ro4lAmE8pKOXG4B< zes2M_Z)knVKWc$KvqI|rZIT~ZSe>JJGFKJ(yL`{0>U?N1wco!4{1T;kJyz24di5-W z{Nu7b#z%Cf9Q$P5s1NwUGZNIMRXlQ_j^%__e{cb%n04&c8C?(>y~g;G&+lw4qq8E3c1i z#I>QhX&UoftQ&MUcW_)&UiWSW9n_rr(^^2kZ_Ryqxt?uM{~}2BW$oZkZqNI3dqBqs zntAd%^(V&DQr|l-K4+6R^hh7>)7)3S@TYg?^{_5nr|Sy6M9|Kk*J)mr0Qkj&czt~^ zv{QHP|By7zAwKTG^EX4FABTd2dh&X{UR={0Lp+wme6BFeebWbAI^ge?L(9KDkoO%K z#5Lt)jvtI%&`_}XFy41t=qw}PXB^4v$3}5Y^P7)W`&3Uq7WJ=!0ppG5sV{Z{&-qP+ zz9UFEV!$Mx|0HS3CC1HDFsJoYaO5=b`E+o|3^2t^kml8y#Wnf=l%aEs&zm-n*E7wB z4qL$e3X7oM3d-wqaxu@pj)1PV6fCuj*H1`#$8yvUtl+uEtGJezOZu^aoX2YPH&_E^ zTFd7x5!z`T{9}SNS7x4#$i3Xe=M0R5_SnpQ>d&}^`>%!e+{XQ|om^Lm;+p0WOYcIx z-EQ!>Ak~Sv_o8kQ&FAIY2fazKzyV&T{+R}Rswb7D4`P0^!+bdfj&eO!(z{RaIxWxR zB=y#rdf2OWSJcobxg}OffCHL)KaeZIXk6)uc z_AOZJJ=p&v82JgL^{V}uYx0R#Mg7@#b?*ER_&rubp_czI?AKBFur1`{;$>1kX z0j?LMI*KV%GAgj}feE$@32-9btv~yh=Pr^NLl5f6ER$ zRz;noydk!-SNF}Y2ETI+Ue8yPYeRF_O1Y}F)P36=;BRyU=hs%}XgPPB)%Bru;Fqoo zz7lk+4}DiK+y&aEAy~x~jGr&`b2sk4Z^Cu0rqE{v8#d>4rxwsB1!?}bmOMxP^j7do zwC43Vp&Pa5{tZdf9M_IK_gd1FBhKo?^CdmGrW|pLRBz#BJWqYQy^(9{1LpMQeQi5) zz21*&nj>?wKhG`d20cBH`vrob4++)}fzBVwb2NX80iWtg<)&VI{+Hg+)_u4y&-3YP zygsHM>LvPv0Rwox`XK1bgSjs+N7e_1sPh|!!gn6V>t%*>Ezcu;NXo^GK;N2?y#LrJ zt~ZR~n&vf`!2Ko@xu%@kB=}V)^Lp_q&|3s4zicY}2Ge++>dmIBeX0}F%;LFUv!SQV z;r`ya&_m~grr}_*MLg%RnCmwYT+dp<_1&dh(|XBVvdnm{{0h{otl>HHwOk*NG%d$< z1J4cH$Tj5*vFaw|&k9nmPbB8eVecLXn>m9Ff|I=0Ix7WB&^XlH<{>hurb>qOQw|SlV`rlRiruVsj z^8wdG9&%0dx;%zo{E50wIb!;!JU8wc^x7BT%a>r8*Wf)t>VNqb{`7aC&3lmQE+4oi z-{B+o3w(mUD@Zw+CB7hM{*Cvi`wks0NPX{r!mnnUiL4~Cd@`QDD|GS{@S_B2*!Gk> zPd>3|8g)HYTKGrOsq57LIX&vfGl1JOf4uTKSM?x(5)y-l!nU0$dDM+W=`4UqS8;eDnJxu!Y9Z;8}PHs<}yBz?FEuhZN< z?(i=+Q`aeXpgFHkZUJ4m64E;Jdj)_2fjn;+#Pvf-XYbDIv|O1-L~d6P zb>20E`_CjT&y%%(FZBEN;dA8Nt3>LQ@86ftN!^d@X+rn!&wc8DG64Sgf#A?VJU3x5 z^uZzAUp18LTEn=e`7$>QN6vL*((=^*N#y&FLSN_6;5WgIW7PAuj#K+IxB7VFb;=RT zPeA^|MDW@q-XAuZ>%~)`Yft6=J4w@gV)f}fKXV4O<4mySZ1D0No}>N>^WZn04}KLa zw@{s@zC)t!AI@`i7DJy9q&)FX1kZ;p;hJ)Nm#TfL8{)2I=yO;OR$Kwz7o5LJJ@>$B z_zTy7jn{&!)`1S|!G;?^T7I%f=nk8~DqDD+azu}+T1~9pH89D{~P3Ho?b-dG7KtuBp%LgxaTiVw`i5_ZK^D3D78rbqWSo#)NJPsUn z52W>*eII)41F+XaUjHWamPg$0{g`W-SK}G{4bOSq{}tDiC+2&tt~i%QGZ~q|P>O9GiUnf{G#ozVQ z@GU9P=b9RvlmtHkJG nH5b>Z z%%S%Smd*!}2|I7+tCQJ3arNXaig?c}0@M0x(zI0{yE$q~F+bZ0TmbARyuJ$}H z*JYivD$mca4!yYs_ixsM4s`%)IfC7scPpk-V*iPt$8kUTj)=M*W2+r%_p|%psxFLg#Sa3^2E4Ks6X-q z)A)c71?P2!&g%zKpUm?9>iQkwUkKp!ev-;?KC_Trl6 z%ADI9xyxbThrVFx{_6e>lD}X8atj9Wyz>yQ<>eaEu0zrHL2$w_KBxY0uCtHe+J7Y1 zw4Ah~;Aa>ORvE){FC|TViSgA~K8NxL$HBim0lYO4w4JQZQ=iOyQ;g>)P384eGq_$N zbn}_qKQ@c&@w1_q&*46;&)&I`KOg#nAmtt|fN!}7Y_b@fumq%B%u=q&|FjH#+;U!z zT>-s!HTS8HxPA@lPHVxs>v+DzFSt*6 zndd|<`X$dle+3=;8oc=i9PyUtJ@BxUs*e@o$R44t8$;_%G@V%-qn!*T%Gq7sR^B~7WZjRO9%K} z9o6+R&hWPh)~ln=(L9;=q)06e<8ELwcb-4fl68R5;R44Xsje7ewNt;W3wcD!m9}M_I+o|)zJ8<8wBXo=)E$>q& z_`zP_ULUZYFSxu5*vSw4C`kQo{_si5d~Bc|6`<~O4pjS(4EVIX62a(u)1CLf4}ty? z%6;lfDg%0mp=tv@-+8p?o;89h(W#eIk4Dy@QGl$ z3(z+&f!!~IC$E7tPp0<`b-m3^wLj$+eA_s1zY_02z^OaJ6P%^m*>em;||Wc^FLBF))ps-C+r8T@)Fczs$*t|z93 z&YOn&7bTrG9j~7h+ARb3>6d#Z`R19Bn=e>8i@J~ciOaI8b9J-9FPj~_FGzjCx!_OE z&HHPbL;L07eulhU2jzp_mmjpX;B{Kg2LnFUO$zhAi;|AdNk1$v!uzDM$+x1YCoch- zmISYtHr_Y8Eb67pfg1(o`G)kG^5|P!0W4S%l=B%ax&KwtH>^?LUWw;=*l;b+CB3<_ zI_GW+zpcHfS5xO`PC#|kKMSs^0bQ*o*u(+M;|NmUVxbp1!Eap~{3b}b*L8Rw`3392 zPgWm1DMPsO}%)s`jbh5Wh4+-z7J7|B5DRpXNEbqu#YCn5r2#qdDl*0;Igm z_oCjn6>=@xsPl2c-`5uPBkjN@9n^VwIi%BhsPhp9{Q4b{zb`nile(Yg6U{t%?z7M% zy|`b^o9jY8(B*x(Pjf#S@Tnfq1%3Iuf)oAKb1Vb6e_3enK={3az`nttQxEWwAT94z zPxzz_@ktnRx%%?FTYs*p|JDGt|7Z~WyhFgSp***L7}sq_a82|7RhAsd=N1{ob)7L> zyN`puEtqTqbhn9M+DSZbGX=WFba40#UZ?dxHcRaXajPTw;9QQ>i{`8P8W(4!vdt_;V##dJWIf@^%To z(^}Nqtplg52TeDs`=~!L?laI|CK7WmZ07TaZsA&zwQ8Z)kEB`c9?5? zsvF`#kzZYj_vN+adX><3?cwLC24=1S=C29v5tNtL#sPKmGdgiSvo_ap&d?p}fR_b# z)`dP_kLPKw%q8{Jx$F(#mv8|eHw0(9f@>Rt^1PQ#xIf&T>n%;8Co~6Bx8!x2SGyJb zL#@?y${lZmdfE2IbCj1E)j{3Yup{?-cY?m+1>W-pLwvv?zF_9g;08g@F3|FFNt<`& z^({iXcjG?g7X`w%4FXRGgN;H#>z*Lx8}#Bje;C)48{HRvmwsSWe{jb@u<>A!@-p3r z@%ksB>x|&O+$ZZgqmh3l_;ZZ${)n-tR~W~0w}n12p8N9h64NIpqQC1Tu;3Ih`&8p| z+fL*4Cz5VHlh>~beQp-~&a-(vem&=KKV0Y*^SJ*~=-vz9cUcH_TLd0o%=3pLpskm3 ZKYqE1{BUj=`hG4q-al@I@j5N${{dprjGX`g literal 548224 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�Q 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

Co6aYV$M3 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

=0&c${zVT%4rB@FcnB*Z&%W-hJ$_yZR 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 z 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 for Option { #[wasm_bindgen(getter_with_clone)] pub struct Binding { pub key: String, - pub commands: Vec, + pub(crate) commands: Vec, pub when: Option, pub mode: Vec, pub priority: f64, @@ -578,6 +578,29 @@ impl Binding { return scope.expand(&self.repeat)?.resolve("`repeat`", scope); } + pub fn commands(&self, scope: &mut Scope) -> ResultVec> { + let mut commands = scope.expand(&self.commands)?; + for _ in 1..10 { + if commands.is_constant() { + break; + } else { + commands = scope.expand(&commands)?; + } + } + commands.require_constant()?; + + let mut regular_commands = Vec::new(); + for command in commands { + let mut sub_commands = regularize_commands(&command, scope)?; + regular_commands.append(&mut sub_commands) + } + + return Ok(regular_commands + .into_iter() + .filter(|x| !bool::from(x.skipWhen.clone())) + .collect()); + } + pub(crate) fn new(input: BindingInput, scope: &mut Scope) -> ResultVec { if let Some(_) = input.id { return Err(err("`id` field is reserved"))?; @@ -1020,7 +1043,7 @@ mod tests { let result = Binding::new(input, &mut scope).unwrap(); scope.state.set_or_push("joe", Dynamic::from("fiz")); - let flat_args = result.commands[0].toml_args(&mut scope).unwrap(); + let flat_args: toml::Value = result.commands(&mut scope).unwrap()[0].clone().args.into(); let mut args_expected = toml::map::Map::new(); args_expected.insert( diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 316a55ce..7f388863 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -1,6 +1,7 @@ #[allow(unused_imports)] use log::info; +use core::ops::Range; use serde::{Deserialize, Serialize}; use std::collections::HashMap; use toml::Spanned; @@ -117,24 +118,73 @@ impl From for Value { } } +pub(crate) trait CommandInputLike { + fn command(&self, scope: &mut Scope) -> ResultVec; + fn args(&self) -> Option>; + #[allow(non_snake_case)] + fn skipWhen(&self) -> TypedValue { + return TypedValue::Constant(false); + } +} + +struct CommandValue<'a> { + command: String, + args: Option<&'a Value>, + range: Range, +} + +impl<'a> CommandInputLike for CommandValue<'a> { + fn command(&self, _scope: &mut Scope) -> ResultVec { + return Ok(self.command.clone()); + } + fn args(&self) -> Option> { + match self.args { + Some(args) => Some(Spanned::new(self.range.clone(), args.clone())), + Option::None => None, + } + } +} + +impl CommandInputLike for BindingInput { + fn command(&self, scope: &mut Scope) -> ResultVec { + return Ok(self.command.clone().resolve("command", scope)?); + } + + fn args(&self) -> Option> { + return self.args.clone(); + } +} + +impl CommandInputLike for Command { + fn command(&self, _scope: &mut Scope) -> ResultVec { + return Ok(self.command.clone()); + } + fn args(&self) -> Option> { + return Some(Spanned::new(UNKNOWN_RANGE, self.args.clone())); + } + fn skipWhen(&self) -> TypedValue { + return self.skipWhen.clone(); + } +} + pub(crate) fn regularize_commands( - input: &BindingInput, + input: &impl CommandInputLike, scope: &mut Scope, ) -> ResultVec> { - let command: String = resolve!(input.clone(), command, scope)?; + let command: String = input.command(scope)?; if command != "runCommands" { let commands = vec![Command { command, - args: match &input.args { + args: match input.args() { None => Value::Table(HashMap::new()), Some(spanned) => spanned.as_ref().clone(), }, - skipWhen: TypedValue::Constant(false), + skipWhen: input.skipWhen(), }]; return Ok(commands); } else { - let spanned = input - .args + let args = input.args(); + let spanned = args .as_ref() .ok_or_else(|| err("`runCommands` must have `args` field"))?; let args_pos = spanned.span(); @@ -177,24 +227,47 @@ pub(crate) fn regularize_commands( .with_range(&args_pos)?; } }; - let result = match kv.get("args") { - Option::None => &Value::Table(HashMap::new()), - Some(x) => x, - }; - let args = match result { - x @ Value::Table(_) => x, - x @ Value::Array(_) => x, - _ => { - return Err(err("expected `args` to be a table or array"))?; + // check for recursive `runCommands` call + // and recursively regularize it if present + if command_name == "runCommands" { + if kv.get("skipWhen").is_some() { + // TODO: support `skipWhen` by injecting + // it into the children commands below + Err(err( + "`skipWhen` is not supported on a `runCommands` command", + )) + .with_range(&args_pos)?; } - }; + let mut commands = regularize_commands( + &(CommandValue { + command: command_name, + args: kv.get("args"), + range: args_pos.clone(), + }), + scope, + )?; + command_result.append(&mut commands); + continue; + } else { + let result = match kv.get("args") { + Option::None => &Value::Table(HashMap::new()), + Some(x) => x, + }; + let args = match result { + x @ Value::Table(_) => x, + x @ Value::Array(_) => x, + _ => { + return Err(err("expected `args` to be a table or array"))?; + } + }; - let result = match kv.get("skipWhen") { - Option::None => Value::Boolean(false), - Some(x) => x.clone(), - }; - let skipWhen: TypedValue = result.try_into()?; - (command_name, args.to_owned(), skipWhen) + let result = match kv.get("skipWhen") { + Option::None => Value::Boolean(false), + Some(x) => x.clone(), + }; + let skipWhen: TypedValue = result.try_into()?; + (command_name, args.to_owned(), skipWhen) + } } _ => { return Err(err( @@ -224,14 +297,10 @@ pub struct Command { #[wasm_bindgen] impl Command { - pub(crate) fn toml_args(&self, scope: &mut Scope) -> ResultVec { - let flat_args = scope.expand(&self.args)?; - return Ok(toml::Value::from(flat_args)); - } - - pub fn args(&self, scope: &mut Scope) -> ResultVec { + pub fn args(&self) -> ResultVec { let to_json = serde_wasm_bindgen::Serializer::json_compatible(); - return match self.toml_args(scope)?.serialize(&to_json) { + let toml: toml::Value = self.args.clone().into(); + return match toml.serialize(&to_json) { Err(e) => Err(err!("object failed to serialize: {e}"))?, Ok(x) => Ok(x), }; @@ -260,6 +329,37 @@ impl Resolving for CommandInput { } } +impl Expanding for Command { + fn is_constant(&self) -> bool { + return self.skipWhen.is_constant() && self.args.is_constant(); + } + + fn map_expressions(self, f: &mut F) -> ResultVec + where + Self: Sized, + F: FnMut(Expression) -> Result, + { + let mut errors = Vec::new(); + let result = Command { + command: self.command, + args: self.args.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + Value::Table(HashMap::new()) + }), + skipWhen: self.skipWhen.map_expressions(f).unwrap_or_else(|mut e| { + errors.append(&mut e.errors); + TypedValue::Constant(false) + }), + }; + + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(result); + } + } +} + #[cfg(test)] mod tests { use crate::bind::command::regularize_commands; @@ -347,4 +447,37 @@ mod tests { "expected `args.commands.command` field for `runCommands`" ); } + + #[test] + fn command_gets_flattened() { + let data = r#" + command = "runCommands" + + [[args.commands]] + command = "a" + + [[args.commands]] + command = "b" + + [[args.commands]] + command = "runCommands" + args.commands = ["biz", "baz"] + "#; + + let bind = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let commands = regularize_commands(&bind, &mut scope).unwrap(); + assert_eq!( + commands + .iter() + .map(|x| x.command.clone()) + .collect::>(), + [ + "a".to_string(), + "b".to_string(), + "biz".to_string(), + "baz".to_string() + ] + ) + } } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index d5cc6f6a..add7c4df 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -256,12 +256,13 @@ impl Define { } pub fn add_to_scope(&self, scope: &mut Scope) -> ResultVec<()> { + let mut val = rhai::Map::new(); for (k, v) in self.val.iter() { v.require_constant()?; - let val: Dynamic = v.clone().into(); - // TODO: add all of these to a `val.` value - scope.state.set_or_push(k, val); + let item: Dynamic = v.clone().into(); + val.insert(k.into(), item); } + scope.state.set_or_push("val", val); return Ok(()); } diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 7170e9e7..bc83fa92 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -142,6 +142,7 @@ impl Scope { } return Ok(obj.clone().map_expressions(&mut |expr| { let ast = &self.asts[&expr.content]; + info!("expression: {expr:?}"); let rewind_to = self.state.len(); for (k, v) in &expr.scope { @@ -149,9 +150,11 @@ impl Scope { self.state.push_dynamic(k, val); } let dynamic: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; + info!("expression value: {dynamic:?}"); self.state.rewind(rewind_to); let result_value: std::result::Result = dynamic.clone().try_into(); let value = result_value.with_message(format!(" while evaluating:\n{expr}"))?; + info!("value: {value:?}"); return Ok(value); })?); } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 5e36244e..2ca8eefc 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -394,9 +394,13 @@ mod tests { assert_eq!(result.bind.len(), 10); for i in 0..9 { + let args: toml::Value = result.bind[i].commands(&mut scope).unwrap()[0] + .clone() + .args + .into(); assert_eq!(result.bind[i].doc.name, expected_name[i]); assert_eq!( - result.bind[i].commands[0].toml_args(&mut scope).unwrap(), + args, toml::Value::Table( [( "value".to_string(), @@ -436,7 +440,7 @@ mod tests { [[bind]] key = "x" - command = "{{foo}}" + command = "{{val.foo}}" args.val = 2 "#; @@ -610,6 +614,49 @@ mod tests { assert_eq!(report[0].range.start.line, 14) } + #[test] + fn command_expansion() { + let data = r#" + [[define.val]] + flag = true + bar = "test" + + [[define.command]] + id = "foo" + command = "runCommands" + args.commands = ["a", "b", "c"] + + [[bind]] + key = "x" + command = "runCommands" + + [[bind.args.commands]] + command = "x" + args.val = 1 + args.name = "{{val.bar}}" + + [[bind.args.commands]] + command = "y" + skipWhen = "{{val.flag}}" + + [[bind.args.commands]] + command = "runCommands" + args.commands = ["j", "k", "{{command.foo}}"] + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let commands = result.bind[0].commands(&mut scope).unwrap(); + assert_eq!(commands[0].command, "x"); + assert_eq!(commands[1].command, "j"); + assert_eq!(commands[2].command, "k"); + assert_eq!(commands[3].command, "a"); + assert_eq!(commands[4].command, "b"); + assert_eq!(commands[5].command, "c"); + assert_eq!(commands.len(), 6); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index c5454b7b..efbe271b 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -204,7 +204,7 @@ impl Merging for toml::Value { } // -// ---------------- ClosedSet ---------------- +// ---------------- Subset ---------------- // pub enum Subset { From c5b54f2c4be84d54f4edff6e9c8f3e5752aeb61a Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 1 Oct 2025 12:33:15 -0400 Subject: [PATCH 60/79] `finalKey` validation Created using spr 1.3.6-beta.1 --- notes.md | 10 ++--- src/rust/parsing/src/bind.rs | 71 ++++++++++++++++++++---------- src/rust/parsing/src/expression.rs | 3 -- src/rust/parsing/src/file.rs | 6 +++ 4 files changed, 58 insertions(+), 32 deletions(-) diff --git a/notes.md b/notes.md index 5e61f052..5de34a78 100644 --- a/notes.md +++ b/notes.md @@ -208,16 +208,16 @@ Integration test debugging: - [X] get existing unit tests working - [X] add unit tests for recurisve `runCommands` called resolved at runtime - [ ] check constraints - - [ ] validation that `master-key.prefix` uses `finalKey: false` + - [X] validation that `master-key.prefix` uses `finalKey: false` - [ ] no duplicate keybindings: hash each key prefix & mode & when-clause - [ ] create a map of valid prefixes - - [ ] insert `editorTextFocus` (or palette context) for bare keys - with no prefix + - [ ] insert `editorTextFocus` for bare keys + - [ ] replace `editorTextFocus` with check for palette context - [ ] implement the `all` functions: - [ ] `{{all_prefixes()}}` - - [ ] `{{all_prefixes_but()}}` + - [ ] `{{not_prefixes()}}` - [X] `{{all_modes()}}` - - [X] `{{all_modes_but(["not_me", "or_me"])}}` + - [X] `{{not_modes(["not_me", "or_me"])}}` - [ ] documentation expansion/validation across all `[[bind]]` values with the same key and mode e.g. merge all shared documentation across the shared names diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 9a10107b..786c117f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -602,40 +602,34 @@ impl Binding { } pub(crate) fn new(input: BindingInput, scope: &mut Scope) -> ResultVec { + let commands = regularize_commands(&input, scope)?; + + // id validation if let Some(_) = input.id { return Err(err("`id` field is reserved"))?; } + // foreach validation if let Some(_) = input.foreach { return Err(err("`foreach` included unresolved variables"))?; } - let commands = regularize_commands(&input, scope)?; - // TODO this is where we should validate that prefix has `finalKey == false` + // finalKey validation + let has_prefix = commands.iter().any(|c| c.command == "master-key.prefix"); + #[allow(non_snake_case)] + let finalKey: bool = resolve!(input, finalKey, scope)?; + if has_prefix && !finalKey { + return Err(err( + "`finalKey` must be `false` when `master-key.prefix` is run", + ))?; + } - let mode_span = match input.mode { - Some(ref mode) => mode.span().clone(), - Option::None => UNKNOWN_RANGE, + // mode validation + let (mode_span, mode) = match input.mode { + Some(ref mode) => (mode.span().clone(), mode.clone().resolve("mode", scope)?), + Option::None => (UNKNOWN_RANGE, vec![scope.default_mode.clone()]), }; - - let result = Binding { - commands: commands, - key: resolve!(input, key, scope)?, - when: resolve!(input, when, scope)?, - mode: match input.mode { - Option::None => vec![scope.default_mode.clone()], - Some(mode) => mode.clone().resolve("mode", scope)?, - }, - priority: resolve!(input, priority, scope)?, - prefixes: resolve!(input, prefixes, scope)?, - finalKey: resolve!(input, finalKey, scope)?, - repeat: resolve!(input, repeat, scope)?, - tags: resolve!(input, tags, scope)?, - doc: resolve!(input, doc, scope)?, - }; - - let undefined_modes: Vec<_> = result - .mode + let undefined_modes: Vec<_> = mode .iter() .filter(|x| !scope.modes.contains(x.as_str())) .collect(); @@ -651,6 +645,20 @@ impl Binding { .with_range(&mode_span)?; } + // resolve all keys to appropriate types + let result = Binding { + commands: commands, + key: resolve!(input, key, scope)?, + when: resolve!(input, when, scope)?, + mode, + priority: resolve!(input, priority, scope)?, + prefixes: resolve!(input, prefixes, scope)?, + finalKey, + repeat: resolve!(input, repeat, scope)?, + tags: resolve!(input, tags, scope)?, + doc: resolve!(input, doc, scope)?, + }; + return Ok(result); } } @@ -1070,6 +1078,21 @@ mod tests { assert_eq!(report[0].range.start.line, 3); } + #[test] + fn final_key_validation() { + let data = r#" + key = "a" + command = "runCommands" + args.commands = ["a", "master-key.prefix"] + "#; + + let input = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let err = Binding::new(input, &mut scope).unwrap_err(); + let report = format!("{err}"); + assert!(report.contains("`finalKey`")); + } + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index bc83fa92..7170e9e7 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -142,7 +142,6 @@ impl Scope { } return Ok(obj.clone().map_expressions(&mut |expr| { let ast = &self.asts[&expr.content]; - info!("expression: {expr:?}"); let rewind_to = self.state.len(); for (k, v) in &expr.scope { @@ -150,11 +149,9 @@ impl Scope { self.state.push_dynamic(k, val); } let dynamic: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; - info!("expression value: {dynamic:?}"); self.state.rewind(rewind_to); let result_value: std::result::Result = dynamic.clone().try_into(); let value = result_value.with_message(format!(" while evaluating:\n{expr}"))?; - info!("value: {value:?}"); return Ok(value); })?); } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 2ca8eefc..6fa6eeee 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -174,6 +174,12 @@ impl KeyFile { // final error output (e.g. if we have [[bind]] item with // foreach.key = [1,2,3] we don't want an error about a missing // required `key` field` to show up three times + + // TODO: this is where we want to register each mode/prefix/when + // pairing and validate that there are no duplicates + // (we should map these pairings to spans where the + // bindings were first defined so we can make good + // error messages) let items = replicates .into_iter() .map(|x| Binding::new(x, &mut scope)) From e5c2a646b7f3424c57479237fcd07844d54f47be Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 1 Oct 2025 23:03:17 -0400 Subject: [PATCH 61/79] bare-key handling tests Created using spr 1.3.6-beta.1 --- notes.md | 8 ++- src/rust/parsing/src/bind.rs | 79 ++++++++++++++++++++++++-- src/rust/parsing/src/bind/command.rs | 12 +++- src/rust/parsing/src/file.rs | 83 ++++++++++++++++++++++++++-- 4 files changed, 169 insertions(+), 13 deletions(-) diff --git a/notes.md b/notes.md index 5de34a78..38f2770b 100644 --- a/notes.md +++ b/notes.md @@ -209,10 +209,11 @@ Integration test debugging: - [X] add unit tests for recurisve `runCommands` called resolved at runtime - [ ] check constraints - [X] validation that `master-key.prefix` uses `finalKey: false` + - [X] encode bindings as a vector of key sequences + - [X] insert `editorTextFocus` for bare keys + - [X] replace `editorTextFocus` with check for palette context - [ ] no duplicate keybindings: hash each key prefix & mode & when-clause - [ ] create a map of valid prefixes - - [ ] insert `editorTextFocus` for bare keys - - [ ] replace `editorTextFocus` with check for palette context - [ ] implement the `all` functions: - [ ] `{{all_prefixes()}}` - [ ] `{{not_prefixes()}}` @@ -236,6 +237,9 @@ Integration test debugging: keybinding file - [ ] implement `[header]` section - [ ] instead of using `.mk.toml`, look for a specific heading in the file + - [ ] error handling checks + - [ ] make sure a range is always provided + - [ ] test that all error messages show up when expected - [ ] proper conversion to keybindings.json command - [ ] expand per mode and prefix (e.g. each binding has one mode and one prefix) - [ ] encode prefixes as prefixCode in when clause diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 786c117f..c192c2e0 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -2,6 +2,8 @@ use log::info; use indexmap::IndexMap; +use lazy_static::lazy_static; +use regex::Regex; use serde::{Deserialize, Serialize}; use std::convert::identity; use toml::Spanned; @@ -560,7 +562,7 @@ impl Resolving> for Option { #[allow(non_snake_case)] #[wasm_bindgen(getter_with_clone)] pub struct Binding { - pub key: String, + pub key: Vec, pub(crate) commands: Vec, pub when: Option, pub mode: Vec, @@ -572,6 +574,15 @@ pub struct Binding { pub doc: BindingDoc, } +const BARE_KEY_CONTEXT: &str = "(editorTextFocus || master-key.keybindingPaletteOpen \ + && master-key.keybindingPaletteBindingMode)"; + +lazy_static! { + static ref WHITESPACE: Regex = Regex::new(r"\s+").unwrap(); + static ref NON_BARE_KEY: Regex = Regex::new(r"(?i)Ctrl|Alt|Cmd|Win|Meta").unwrap(); + static ref EDITOR_TEXT_FOCUS: Regex = Regex::new(r"\beditorTextFocus\b").unwrap(); +} + #[wasm_bindgen] impl Binding { pub fn repeat(&mut self, scope: &mut Scope) -> ResultVec { @@ -595,10 +606,21 @@ impl Binding { regular_commands.append(&mut sub_commands) } - return Ok(regular_commands + let commands: Vec<_> = regular_commands .into_iter() .filter(|x| !bool::from(x.skipWhen.clone())) - .collect()); + .collect(); + + // finalKey validation + let has_prefix = commands.iter().any(|c| c.command == "master-key.prefix"); + #[allow(non_snake_case)] + if has_prefix && !self.finalKey { + return Err(err( + "`finalKey` must be `false` when `master-key.prefix` is run", + ))?; + } + + return Ok(commands); } pub(crate) fn new(input: BindingInput, scope: &mut Scope) -> ResultVec { @@ -645,11 +667,30 @@ impl Binding { .with_range(&mode_span)?; } + // require that bare keybindings (those without a modifier key) + // be specific to `textEditorFocus` / `keybindingPaletteOpen` context + let key_string: String = resolve!(input, key, scope)?; + let key: Vec<_> = WHITESPACE.split(&key_string).map(String::from).collect(); + let mut when: Option = resolve!(input, when, scope)?; + when = if !NON_BARE_KEY.is_match(&key[0]) { + if let Some(w) = when { + Some(format!("({}) && {BARE_KEY_CONTEXT}", w)) + } else { + Some(BARE_KEY_CONTEXT.to_string()) + } + } else { + Some( + EDITOR_TEXT_FOCUS + .replace_all(&(when.unwrap()), BARE_KEY_CONTEXT) + .to_string(), + ) + }; + // resolve all keys to appropriate types let result = Binding { commands: commands, - key: resolve!(input, key, scope)?, - when: resolve!(input, when, scope)?, + key, + when, mode, priority: resolve!(input, priority, scope)?, prefixes: resolve!(input, prefixes, scope)?, @@ -662,7 +703,6 @@ impl Binding { return Ok(result); } } - // // ---------------- `bind.doc` object ---------------- // @@ -1093,6 +1133,33 @@ mod tests { assert!(report.contains("`finalKey`")); } + #[test] + fn bare_bindings_require_editor_focus() { + let data = r#" + key = "a" + command = "foobar" + "#; + + let input = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let result = Binding::new(input, &mut scope).unwrap(); + assert!(result.when.unwrap().contains("editorTextFocus")) + } + + #[test] + fn editor_focus_expands_to_palette_focus() { + let data = r#" + key = "a" + command = "foobar" + when = "editorTextFocus && bizbaz" + "#; + + let input = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let result = Binding::new(input, &mut scope).unwrap(); + assert!(result.when.unwrap().contains("keybindingPaletteOpen")); + } + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 7f388863..4aefe14c 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -256,7 +256,9 @@ pub(crate) fn regularize_commands( let args = match result { x @ Value::Table(_) => x, x @ Value::Array(_) => x, - _ => { + x @ Value::Exp(_) => x, + x => { + info!("x: {x:?}"); return Err(err("expected `args` to be a table or array"))?; } }; @@ -269,6 +271,14 @@ pub(crate) fn regularize_commands( (command_name, args.to_owned(), skipWhen) } } + x @ Value::Exp(_) => ( + "runCommands".to_string(), + Value::Table(HashMap::from([( + "commands".to_string(), + Value::Array(vec![x]), + )])), + TypedValue::Constant(false), + ), _ => { return Err(err( "`commands` to be an array that includes objects and strings only", diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 6fa6eeee..d098f579 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -273,9 +273,9 @@ mod tests { let result = parse_bytes_helper(data.as_bytes()).unwrap(); - assert_eq!(result.bind[0].key, "l"); + assert_eq!(result.bind[0].key[0], "l"); assert_eq!(result.bind[0].commands[0].command, "cursorRight"); - assert_eq!(result.bind[1].key, "h"); + assert_eq!(result.bind[1].key[0], "h"); assert_eq!(result.bind[1].commands[0].command, "cursorLeft"); } @@ -308,7 +308,7 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); - assert_eq!(result.bind[0].key, "a"); + assert_eq!(result.bind[0].key[0], "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, @@ -359,7 +359,7 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); - assert_eq!(result.bind[0].key, "a"); + assert_eq!(result.bind[0].key[0], "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( result.bind[0].commands[0].args, @@ -663,6 +663,81 @@ mod tests { assert_eq!(commands.len(), 6); } + #[test] + fn command_expansion_validates_final_key() { + let data = r#" + [[define.val]] + flag = true + bar = "test" + + [[define.command]] + id = "foo" + command = "runCommands" + args.commands = ["a", "b", "master-key.prefix"] + + [[bind]] + key = "x" + command = "runCommands" + + [[bind.args.commands]] + command = "x" + args.val = 1 + args.name = "{{val.bar}}" + + [[bind.args.commands]] + command = "y" + skipWhen = "{{val.flag}}" + + [[bind.args.commands]] + command = "runCommands" + args.commands = ["j", "k", "{{command.foo}}"] + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("`finalKey`")); + assert_eq!(report[0].range.start.line, 10); + } + + #[test] + fn command_expansion_dynamically_validates_final_key() { + let data = r#" + [[define.val]] + flag = true + bar = "test" + + [[define.command]] + id = "foo" + command = "runCommands" + args.commands = ["a", "b", '{{"master-key" + ".prefix"}}'] + + [[bind]] + key = "x" + command = "runCommands" + + [[bind.args.commands]] + command = "x" + args.val = 1 + args.name = "{{val.bar}}" + + [[bind.args.commands]] + command = "y" + skipWhen = "{{val.flag}}" + + [[bind.args.commands]] + command = "runCommands" + args.commands = ["j", "k", "{{command.foo}}"] + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let err = result.bind[0].commands(&mut scope).unwrap_err(); + assert!(format!("{err}").contains("`finalKey`")) + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) From 48ee91e6e9a563b0ec4469b0f2fafc857dc6b1aa Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 4 Oct 2025 12:17:23 -0400 Subject: [PATCH 62/79] working method to generate keybinding.json output Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 1 + notes.md | 24 +- src/rust/parsing/src/bind.rs | 445 ++++++++++++++++++++++- src/rust/parsing/src/bind/command.rs | 1 - src/rust/parsing/src/error.rs | 108 +++++- src/rust/parsing/src/expression/value.rs | 2 + src/rust/parsing/src/file.rs | 132 ++++++- 7 files changed, 676 insertions(+), 37 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index e1480020..1ef1db9d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -10,6 +10,7 @@ ], "window.title": "vscode-master-key", "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.90.0-aarch64-apple-darwin", + "rust-analyzer.cargo.sysrootSrc": "/Users/davidlittle/.rustup/toolchains/1.90.0-aarch64-apple-darwin/lib/rustlib/src/rust", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, diff --git a/notes.md b/notes.md index 38f2770b..62642ace 100644 --- a/notes.md +++ b/notes.md @@ -207,15 +207,19 @@ Integration test debugging: - [X] flatten all `runCommands` at run-time - [X] get existing unit tests working - [X] add unit tests for recurisve `runCommands` called resolved at runtime - - [ ] check constraints + - [X] check constraints - [X] validation that `master-key.prefix` uses `finalKey: false` - [X] encode bindings as a vector of key sequences - [X] insert `editorTextFocus` for bare keys - [X] replace `editorTextFocus` with check for palette context - - [ ] no duplicate keybindings: hash each key prefix & mode & when-clause - - [ ] create a map of valid prefixes + - [X] no duplicate keybindings: hash each key prefix & mode & when-clause + - [X] create a map of valid prefixes - [ ] implement the `all` functions: - [ ] `{{all_prefixes()}}` + - [ ] implement method to get statically prefixes + - [ ] implement validation check to prevent the definition of *new* + prefixes in an expression + - [ ] register a function for getting `all_prefixes` - [ ] `{{not_prefixes()}}` - [X] `{{all_modes()}}` - [X] `{{not_modes(["not_me", "or_me"])}}` @@ -241,14 +245,22 @@ Integration test debugging: - [ ] make sure a range is always provided - [ ] test that all error messages show up when expected - [ ] proper conversion to keybindings.json command - - [ ] expand per mode and prefix (e.g. each binding has one mode and one prefix) - - [ ] encode prefixes as prefixCode in when clause - - [ ] move mode to when clause + - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) + - [X] encode prefixes as prefixCode in when clause + - [X] move mode to when clause + - [X] generate all binding outputs in file object + - [ ] review existing binding resolution logic to make sure we didn't miss + something + - [ ] unit tests for binding output generation + - [ ] write `BindingOutput` to keybindings.json - [ ] re-implement master-key.do - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make sense) - [ ] move all bare variables in an expression to `key.` or `code.` object - [ ] transfer scope state from TS to rust Scope object + - [ ] set a variable up to track the key code so that if `master-key.prefix` is + called it can use it to set the prefix (alternative you always set this + but we clear it when something isn't the final key) - [ ] properly handle command queues (no controlled by rust) - [ ] guess: don't have special command queue field - [ ] support accessing values by their path (`val.foo`, `key.count`) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index c192c2e0..a82cf1d5 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -1,11 +1,15 @@ #[allow(unused_imports)] use log::info; +use core::ops::Range; use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::collections::hash_map::{Entry, OccupiedEntry}; use std::convert::identity; +use std::iter::Iterator; use toml::Spanned; use wasm_bindgen::prelude::*; @@ -15,12 +19,12 @@ pub mod validation; use crate::bind::command::{Command, regularize_commands}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::err; use crate::error::{ErrorContext, Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; use crate::util::{Merging, Plural, Required, Resolving}; +use crate::{err, wrn}; pub const UNKNOWN_RANGE: core::ops::Range = usize::MIN..usize::MAX; @@ -28,10 +32,17 @@ fn span_required_default() -> Spanned> { return Spanned::new(UNKNOWN_RANGE, Required::DefaultValue); } -fn span_plural_default() -> Spanned>> { +fn span_plural_default() -> Spanned>> +where + T: Serialize + std::fmt::Debug + Clone, +{ return Spanned::new(UNKNOWN_RANGE, TypedValue::default()); } +fn spanned_value_true() -> Spanned> { + return Spanned::new(UNKNOWN_RANGE, TypedValue::Constant(true)); +} + // // ================ `[[bind]]` parsing ================ // @@ -104,7 +115,8 @@ pub struct BindingInput { /// @forBindingField bind /// /// - `priority`: The ordering of the keybinding relative to others; determines which - /// bindings take precedence. Defaults to 0. + /// bindings take precedence. Higher priorities take precedence over lower priorities. + /// Defaults to 0. pub priority: Option>>, /// @forBindingField bind /// @@ -121,24 +133,24 @@ pub struct BindingInput { /// @forBindingField bind /// - /// - `prefixes`: array of strings or an expression of producing such an array. - /// (see also [`all_prefixes`](expressions/functions#all_prefixes)). - /// The prefixes determine one or more *unresolved* key - /// sequences that can have occurred before typing this key. See - /// [`master-key.prefix`](/commands/prefix) for details. Defaults to `""` (a.k.a. - /// no prefix is allowed). Setting this to {{all_prefixes}}, - /// will allow a key binding to work regardless of any unresolved key - /// sequence that has been pressed: this is how `esc` is defined to work - /// in Larkin. + /// - `prefixes`: string, array of strings or an expression producing such a value (e.g. + /// [`all_prefixes`](expressions/functions#all_prefixes)). The prefixes determine one + /// or more *unresolved* key sequences that can have been pressed before typing this + /// key binding. See [`master-key.prefix`](/commands/prefix) for details. Defaults to + /// an empty array, which indicates that no prior keys can have been pressed. Setting + /// this to '{{all_prefixes()}}', will allow a key binding to work + /// regardless of any unresolved key sequence that has been pressed: this is how `esc` + /// is defined to work in Larkin. #[serde(default = "span_plural_default")] - pub prefixes: Spanned>>, + pub prefixes: Spanned>>, /// @forBindingField bind /// /// - `finalKey`: (boolean, default=true) Whether this key should clear any transient /// state associated with the pending keybinding prefix. See /// [`master-key.prefix`](/commands/prefix) for details. - pub finalKey: Option>>, + #[serde(default = "spanned_value_true")] + pub finalKey: Spanned>, /// @forBindingField bind /// @@ -322,7 +334,7 @@ impl Expanding for BindingInput { }), finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - None + spanned_value_true() }), repeat: self.repeat.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -614,7 +626,7 @@ impl Binding { // finalKey validation let has_prefix = commands.iter().any(|c| c.command == "master-key.prefix"); #[allow(non_snake_case)] - if has_prefix && !self.finalKey { + if has_prefix && self.finalKey { return Err(err( "`finalKey` must be `false` when `master-key.prefix` is run", ))?; @@ -640,7 +652,7 @@ impl Binding { let has_prefix = commands.iter().any(|c| c.command == "master-key.prefix"); #[allow(non_snake_case)] let finalKey: bool = resolve!(input, finalKey, scope)?; - if has_prefix && !finalKey { + if has_prefix && finalKey { return Err(err( "`finalKey` must be `false` when `master-key.prefix` is run", ))?; @@ -754,6 +766,405 @@ impl CombinedBindingDoc { } // +// ================ `[[bind]]` output to keybinding.json ================ +// + +// The `Binding` objects are serialized separately (in `settings.json`) and loaded into +// memory when the extension loads. To associate each with a keybinding we serialize an +// associated `KeyBinding` object that makes a call to `master-key.do`; `do` then looks +// up the right `Binding` object based on the `id` field of `KeyBinding` + +// object is a valid JSON object to store in `keybinding.json`; extra metadata is +// stored in the arguments of `master-key.do` +#[derive(Clone, Debug, Serialize)] +#[serde(tag = "command")] +pub enum BindingOutput { + #[serde(rename = "master-key.do")] + Do { + key: String, + when: Option, + args: BindingOutputArgs, + }, + #[serde(rename = "master-key.prefix")] + Prefix { + key: String, + when: Option, + args: PrefixArgs, + }, +} + +impl BindingOutput { + pub fn cmp_priority(&self, other: &Self) -> std::cmp::Ordering { + return match (self, other) { + ( + Self::Do { + args: BindingOutputArgs { priority: a, .. }, + .. + }, + Self::Do { + args: BindingOutputArgs { priority: b, .. }, + .. + }, + ) => f64::total_cmp(a, b), + ( + Self::Prefix { + args: PrefixArgs { priority: a, .. }, + .. + }, + Self::Prefix { + args: PrefixArgs { priority: b, .. }, + .. + }, + ) => f64::total_cmp(a, b), + (Self::Prefix { .. }, Self::Do { .. }) => std::cmp::Ordering::Less, + (Self::Do { .. }, Self::Prefix { .. }) => std::cmp::Ordering::Greater, + }; + } +} + +pub trait KeyId { + fn key_id(&self) -> i32; +} + +impl KeyId for BindingOutputArgs { + fn key_id(&self) -> i32 { + return self.key_id; + } +} + +impl KeyId for PrefixArgs { + fn key_id(&self) -> i32 { + return self.key_id; + } +} + +impl KeyId for BindingOutput { + fn key_id(&self) -> i32 { + match self { + BindingOutput::Do { args, .. } => args.key_id(), + BindingOutput::Prefix { args, .. } => args.key_id(), + } + } +} + +#[derive(Clone, Debug, Serialize)] +pub struct BindingOutputArgs { + // this uniquely identifies the key sequence used pressed for this binding + // (used by nested calls to `master-key.prefix`) + pub(crate) key_id: i32, + // this uniquely identifiers the command that runs after pressing a binding + // (which is retrieved by `maaster-key.do`) + pub(crate) command_id: i32, + // these fields help us track and order binding outputs, we don't need them serialized + #[serde(skip)] + pub(crate) priority: f64, + // these fields are used in tracking and help improve legibility of the output bindings + // in the keybindings.json file, and so they are stored + pub(crate) name: String, + pub(crate) description: String, + pub(crate) prefix: String, + pub(crate) mode: String, +} + +#[derive(Clone, Debug, Serialize)] +pub struct PrefixArgs { + // this uniquely identifies the key sequence used pressed for this binding + pub(crate) key_id: i32, + // human readable field displaying the prefix (there are other arguments to + // `master-key.prefix` but they are not used by automatically generated bindings, which + // is what this type is for) + pub(crate) prefix: String, + // these fields help us track and order binding outputs, we don't need them serialized + #[serde(skip)] + pub(crate) priority: f64, +} + +// BindingId uniquely identifies a the triggers the distinguish different bindings +// if these three fields are the same, there are conflicts in the keybinding file +#[derive(Clone, Debug, PartialEq, Hash)] +struct BindingId { + key: Vec, + mode: String, + when: String, +} +impl Eq for BindingId {} + +// For each unique `BindingId`, we need to know a few things about it +struct BindingProperties { + // the span where the binding was first defined; if we find a second + // definition our error message can point to the first definition + span: Range, + // the code tells us how to create `when` clauses that are conditioned + // on this keypress having already happened (as a prefix) + code: i32, + // whether this binding was defined implicitly as a prefix of an explicit binding, or if + // it was defined explicitly within a keybinding file; all implicit bindings imply the + // same exact command, so it's okay if they overlap. + implicit: bool, +} + +// tracks all unique bindings +pub(crate) struct BindingCodes { + codes: HashMap, + // `count` is used to generate new, unique `id` fields + count: i32, +} + +impl BindingCodes { + pub(crate) fn new() -> Self { + return BindingCodes { + codes: HashMap::new(), + count: 0, + }; + } + pub(crate) fn key_code( + &mut self, + key: &Vec, + mode: &str, + when: &Option, + span: &Range, + implicit: bool, + ) -> ResultVec<(i32, bool)> { + let id = BindingId { + key: key.iter().map(ToString::to_string).collect(), + mode: mode.to_string(), + when: match when { + Some(x) => x.to_string(), + Option::None => "".to_string(), + }, + }; + if let Entry::Occupied(mut old @ OccupiedEntry { .. }) = self.codes.entry(id.clone()) { + // it's okay to overwrite implicit bindings, but we don't want two explicitly + // defined binding + if !old.get().implicit && !implicit { + let errors: Vec> = vec![ + Err(wrn!( + "Duplicate key sequence for mode `{mode}`. First instance is \ + defined at " + )) + .with_range(&span) + .with_ref_range(&old.get().span), + Err(wrn!( + "Duplicate key sequence for mode `{mode}`. This sequence is \ + also defined later in the file at " + )) + .with_range(&old.get().span) + .with_ref_range(&span), + ]; + return Err(errors + .into_iter() + .map(Result::unwrap_err) + .collect::>())?; + } else if !implicit { + // if the new binding is explicit, overwrite the old one + old.insert(BindingProperties { + span: span.clone(), + code: old.get().code, + implicit, + }); + return Ok((old.get().code, true)); + } + return Ok((old.get().code, false)); + } else { + // create a new entry + self.count += 1; + self.codes.insert( + id, + BindingProperties { + span: span.clone(), + code: self.count, + implicit, + }, + ); + + return Ok((self.count, true)); + } + } +} + +fn join_when_vec(when: &Vec) -> Option { + if when.len() == 0 { + return None; + } else { + return Some(format!("({})", when.join(") && ("))); + } +} + +/// Creates all valid prefixes of a vector: e.g. `[a, b, c]` +/// yields `[[a], [a, b], [a, b, c]]`. +pub(crate) fn list_prefixes(seq: impl Iterator) -> Vec> { + let mut all_prefixes = Vec::new(); + let mut current_prefix = Vec::new(); + for key in seq { + current_prefix.push(key); + all_prefixes.push(current_prefix.iter().map(ToString::to_string).collect()) + } + + return all_prefixes; +} + +impl Binding { + // TODO: before this runs we need to extract all possible prefixes and use them to + // implement `all_prefixes` this should be a method of BindingInput we'll need to skip + // all values that aren't constant for `prefixes` + + // when evaluating dynamic prefixes we'll need to verify that such expressions don't add + // new prefixes (should update the docs as well to be clear about this) trying to + // support this otherwise requires some very circular stuff that doesn't really seem + // worth it + + // in many cases you can work around this because you could define a binding with + // `mater-key.prefix` as its command and this would introducing the binding even if the + // `key` filed of this binding had an expression in it... but this means that + // `all_prefixes` cannot be defined during resolution of `key` 🤔 + + /// Generates the `BindingOutput` items that will be stored in `keybindings.json` + /// + /// For each `Binding` item there are actually many implied `keybinding.json` entries. + /// We have to define duplicates for each `mode`, and each `prefix` element. + pub(crate) fn outputs( + &self, + command_id: i32, + scope: &Scope, + span: Range, + codes: &mut BindingCodes, + ) -> ResultVec> { + let mut result = Vec::new(); + + // create a distinct binding for each mode... + for mode in &self.mode { + let mut when_with_mode = match &self.when { + Some(when) => vec![when.clone()], + Option::None => vec![], + }; + if mode != &scope.default_mode { + when_with_mode.push(format!("master-key.mode == '{mode}'")); + } + let prefixes = if self.prefixes.is_empty() { + vec!["".to_string()] + } else { + self.prefixes.clone() + }; + // ...and a distinct binding for each `self.prefix` + for prefix in prefixes { + self.outputs_for_mode_and_prefix( + command_id, + &span, + &mode, + &prefix, + &when_with_mode, + codes, + &mut result, + )?; + } + } + + return Ok(result); + } + + /// there are a few things going on with prefixes in this next function, which are worth + /// delineating between + /// + /// explicit prefixes: those prefixes specified in `[[bind]]`; they list one or more + /// sequences of keys that can occur before the defined keybinding. + /// + /// listed prefixes: this is the complete set of prefixes a given key sequence has, + /// including the explicit prefix (e.g. "a b c" has two prefixes: "a" and "a b") + /// + /// We need to define a separate binding to the actuall command to run (calling + /// `master-key.do`) per explicit prefix. In addition, we need to define a binding per + /// listed prefix because those each require a call to `master-key.prefix` to allow + /// documentation to update between each key-press of a multi-press binding and for user + /// specified keys to cancel a keybinding sequence (the same way escape cancels + /// keybindings in vim). It is also how we could eventually implement vim-like behavior + /// where one binding (e.g. `c` to change a line) could actually be a prefix of another + /// (e.g. `c c` to comment a line). + /// + /// Example: + /// + /// ```toml + /// [[bind]] + /// key = "a b" + /// prefixes = ["x y", "k h"] + /// ``` + /// + /// there are two terminal bindings: one for the "x y" and one for the "k h" explicit + /// prefix. This leads to two iterations of the `for explicit_prefix` loop below, where + /// we generate BindingOutput::Prefix items as follows: + /// + /// - iteration 1 (prefix `"x y"`): `[["x"], ["x", "y"], ["x", "y", "a"]]` + /// - iteration 2 (prefix `"k h"`): `[["k"], ["k", "h"], ["k", "h", "a"]]` + fn outputs_for_mode_and_prefix( + &self, + command_id: i32, + span: &Range, + mode: &str, + explicit_prefix: &str, + when_with_mode: &Vec, + codes: &mut BindingCodes, + result: &mut Vec, + ) -> ResultVec<()> { + // split the current explicit prefix into individual keys and then prepend + // it to the key sequence for this binding + let prefix_seq = WHITESPACE + .split(&explicit_prefix) + .filter(|x| !x.is_empty()) + .chain(self.key.iter().map(String::as_str)); + // generate a keybindings.json entry for each listed prefix of this Binding + let prefixes = list_prefixes(prefix_seq); + let mut old_prefix_code = 0; // 0 is never returned by `key_code` method + let mut old_prefix_str = "".to_string(); + for prefix in prefixes[0..(prefixes.len() - 1)].iter() { + let mut when; + // TODO: key_code should signal when there is already a higher + // priority binding that's been added, and prevent + // us from inserting a new binding here + let (prefix_code, is_new_code) = + codes.key_code(&prefix, &mode, &self.when, span, true)?; + when = when_with_mode.clone(); + when.push(format!("master-key.prefixCode == {old_prefix_code}")); + if is_new_code { + result.push(BindingOutput::Prefix { + key: prefix.last().unwrap().clone(), + when: join_when_vec(&when), + args: PrefixArgs { + priority: 0.0, + key_id: prefix_code, + prefix: old_prefix_str, + }, + }); + } + old_prefix_code = prefix_code; + old_prefix_str = prefix.clone().join(" "); + } + + // generate keybindings.json entry for this Binding's actual + // command + let mut when = when_with_mode.clone(); + when.push(format!("master-key.prefixCode == {old_prefix_code}")); + + // we can unwrap here because non-implicit bindings always + // throw an error if they already exist + let (code, _) = + codes.key_code(&prefixes.last().unwrap(), &mode, &self.when, span, false)?; + + result.push(BindingOutput::Do { + key: self.key.last().unwrap().clone(), + when: join_when_vec(&when), + args: BindingOutputArgs { + command_id, + key_id: code, + mode: mode.to_string(), + priority: self.priority, + prefix: old_prefix_str, + name: self.doc.name.clone(), + description: self.doc.description.clone(), + }, + }); + return Ok(()); + } +} + // ================ Tests ================ // diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index 4aefe14c..d416abfb 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -258,7 +258,6 @@ pub(crate) fn regularize_commands( x @ Value::Array(_) => x, x @ Value::Exp(_) => x, x => { - info!("x: {x:?}"); return Err(err("expected `args` to be a table or array"))?; } }; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 975f8b67..669fa93e 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -3,6 +3,7 @@ use log::info; use core::ops::Range; use rhai::{self, EvalAltResult}; +use serde::Serialize; use smallvec::SmallVec; use std::fmt; use string_offsets::{Pos, StringOffsets}; @@ -43,22 +44,71 @@ macro_rules! err { }; } +#[macro_export] +macro_rules! wrn { + ( $($x:tt)* ) => { + crate::error::Error { + error: crate::error::RawError::Dynamic(format!($($x)*)), + contexts: smallvec::SmallVec::new(), + level: crate::error::ErrorLevel::Warn, + } + }; +} + +#[macro_export] +macro_rules! note { + ( $($x:tt)* ) => { + crate::error::Error { + error: crate::error::RawError::Dynamic(format!($($x)*)) + contexts: smallvec::SmallVec::new(), + level: crate::error::ErrorLevel::Note + } + }; +} + pub fn err(msg: &'static str) -> RawError { return RawError::Static(msg); } +pub fn wrn(msg: &'static str) -> Error { + return Error { + error: RawError::Static(msg), + contexts: SmallVec::new(), + level: ErrorLevel::Warn, + }; +} + +pub fn note(msg: &'static str) -> Error { + return Error { + error: RawError::Static(msg), + contexts: SmallVec::new(), + level: ErrorLevel::Info, + }; +} + #[wasm_bindgen] #[derive(Debug, Error, Clone)] pub struct Error { #[source] pub(crate) error: RawError, pub(crate) contexts: SmallVec<[Context; 8]>, + pub(crate) level: ErrorLevel, +} + +#[wasm_bindgen] +#[derive(Debug, Clone, Default, Serialize)] +pub enum ErrorLevel { + #[default] + Error, + Warn, + Info, } #[derive(Debug, Clone)] pub enum Context { - Message(String), // additional message content to include - Range(Range), // the location of an error in a file + Message(String), // additional message content to include + Range(Range), // the location of an error in a file + RefRange(Range), // another location mentioned in the error message } /// A `Spannable` can be interpreted as a range of byte offsets @@ -85,6 +135,12 @@ impl Spannable for Range { } } +impl Spannable for &Range { + fn range(&self) -> Option> { + return Some(self.to_owned().clone()); + } +} + /// An object implementing `ErrorContext` can store additional context /// about the error being returned. pub trait ErrorContext @@ -97,6 +153,8 @@ where fn with_message(self, context: impl ToString) -> std::result::Result { return self.with_context(Context::Message(context.to_string())); } + // NOTE: we return UNKNOWN_RANGE here because we have to transform the value using + // `.with_context` to keep the return type uniform fn with_range(self, context: &impl Spannable) -> std::result::Result { if let Some(range) = context.range() { return self.with_context(Context::Range(range)); @@ -104,6 +162,13 @@ where return self.with_context(Context::Range(UNKNOWN_RANGE)); } } + fn with_ref_range(self, context: &impl Spannable) -> std::result::Result { + if let Some(range) = context.range() { + return self.with_context(Context::RefRange(range)); + } else { + return self.with_context(Context::RefRange(UNKNOWN_RANGE)); + } + } } impl ErrorContext for Result { @@ -116,6 +181,7 @@ impl ErrorContext for Result { Err(Error { error: e.error, contexts: e.contexts, + level: e.level, }) } }; @@ -129,6 +195,7 @@ impl> From for Error { return Error { error: error.into(), contexts: SmallVec::new(), + level: ErrorLevel::default(), }; } } @@ -206,6 +273,7 @@ impl> ErrorContext for std::result::Result { Err(Error { error: e.into(), contexts, + level: ErrorLevel::default(), }) } }; @@ -243,6 +311,9 @@ impl fmt::Display for Error { Context::Range(range) => { write!(f, "byte range {:?}\n", range)?; } + Context::RefRange(range) => { + write!(f, "and byte range {:?}\n", range)?; + } } } self.error.fmt(f)?; @@ -290,6 +361,7 @@ impl Error { let offsets: StringOffsets = StringOffsets::from_bytes(content); let mut message_buf = String::new(); let mut range = UNKNOWN_RANGE; + let mut ref_range = UNKNOWN_RANGE; let mut char_line_range = None; let mut rhai_pos = None; match &self.error { @@ -324,12 +396,22 @@ impl Error { } } } + Context::RefRange(new_range) => { + if new_range != &UNKNOWN_RANGE { + ref_range = new_range.clone(); + } + } }; } if let Some(cl_range) = char_line_range { + if ref_range != UNKNOWN_RANGE { + let pos = range_to_pos(&ref_range, &offsets); + message_buf.push_str(&format!("{pos}")); + }; return ErrorReport { message: message_buf, range: cl_range, + level: self.level.clone(), }; } else { return ErrorReport { @@ -338,6 +420,7 @@ impl Error { message_buf ), range: CharRange::default(), + level: ErrorLevel::Error, }; } } @@ -357,6 +440,25 @@ pub struct CharRange { pub end: Pos, } +impl std::fmt::Display for CharRange { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { + if self.start.line == self.end.line { + if self.start.col == self.end.col { + write!(fmt, "line {}, column {}", self.start.line, self.start.col)?; + } else { + write!( + fmt, + "line {}, columns {} - {}", + self.start.line, self.start.col, self.end.col + )?; + } + } else { + write!(fmt, "lines {} - {}", self.start.line, self.end.line)?; + } + return Ok(()); + } +} + impl Default for CharRange { fn default() -> Self { return CharRange { @@ -371,6 +473,7 @@ impl Default for CharRange { pub struct ErrorReport { pub message: String, pub range: CharRange, + pub level: ErrorLevel, } #[wasm_bindgen] @@ -380,6 +483,7 @@ impl ErrorReport { return ErrorReport { message: String::from(""), range: CharRange::default(), + level: ErrorLevel::default(), }; } } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 4f2983ba..b562700e 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -276,6 +276,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match error = Some(Error { error: err("unexpected `{{`"), contexts: smallvec![crate::error::Context::Range(exp_span.clone())], + level: crate::error::ErrorLevel::Error, }); } return Ok(Value::Exp(Expression { @@ -291,6 +292,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match error = Some(Error { error: err("unexpected `{{`"), contexts: smallvec![], + level: crate::error::ErrorLevel::Error, }); } return Ok(Value::Exp(Expression { diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index d098f579..23669174 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -83,15 +83,16 @@ /// args.value = "{{foo+1}}" /// ``` #[allow(unused_imports)] -use log::info; +use log::{error, info}; -use crate::bind::{Binding, BindingInput, UNKNOWN_RANGE}; +use crate::bind::{Binding, BindingCodes, BindingInput, BindingOutput, KeyId, UNKNOWN_RANGE}; use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; use crate::expression::Scope; use crate::mode::{ModeInput, Modes}; use serde::{Deserialize, Serialize}; +use std::collections::{HashSet, VecDeque}; use toml::Spanned; use wasm_bindgen::prelude::*; @@ -109,10 +110,9 @@ pub struct KeyFile { define: Define, modes: Modes, bind: Vec, + key_bind: Vec, } -// TODO: implement methods to access/store bindings - impl KeyFile { // TODO: refactor to have each section's processing in corresponding module // for that section @@ -161,7 +161,7 @@ impl KeyFile { .parse_asts(&bind_input) .map_err(|mut es| errors.append(&mut es.errors)); - let bind: Vec<_> = bind_input + let bind_and_span: Vec<_> = bind_input .into_iter() .flat_map(|x| { let span = x.span().clone(); @@ -175,14 +175,9 @@ impl KeyFile { // foreach.key = [1,2,3] we don't want an error about a missing // required `key` field` to show up three times - // TODO: this is where we want to register each mode/prefix/when - // pairing and validate that there are no duplicates - // (we should map these pairings to spans where the - // bindings were first defined so we can make good - // error messages) let items = replicates .into_iter() - .map(|x| Binding::new(x, &mut scope)) + .map(|x| Ok((Binding::new(x, &mut scope)?, span.clone()))) .collect::>>() .with_range(&span); match items { @@ -201,10 +196,31 @@ impl KeyFile { }) .collect(); + // TODO: store spans so we can do avoid serializing this data?? + let mut key_bind = Vec::new(); + let mut bind = Vec::new(); + let mut codes = BindingCodes::new(); + for (i, (bind_item, span)) in bind_and_span.into_iter().enumerate() { + key_bind.append(&mut bind_item.outputs(i as i32, &scope, span, &mut codes)?); + bind.push(bind_item); + } + key_bind.sort_by(BindingOutput::cmp_priority); + // remove key_bind values with the exact same `key_id`, keeping the one + // with the highest priority (last items) + let mut seen_codes = HashSet::new(); + let mut final_key_bind = VecDeque::with_capacity(key_bind.len()); + for key in key_bind.into_iter().rev() { + if !seen_codes.contains(&key.key_id()) { + seen_codes.insert(key.key_id()); + final_key_bind.push_front(key); + } + } + if errors.len() == 0 { return Ok(KeyFile { define, bind, + key_bind: final_key_bind.into(), modes, }); } else { @@ -243,6 +259,7 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { #[cfg(test)] mod tests { use super::*; + use crate::bind::BindingOutputArgs; use crate::bind::UNKNOWN_RANGE; use crate::expression::value::Expression; use crate::expression::value::Value; @@ -738,6 +755,99 @@ mod tests { assert!(format!("{err}").contains("`finalKey`")) } + #[test] + fn output_bindings_overwrite_implicit_prefix() { + let data = r#" + [[bind]] + key = "a b" + command = "foo" + + [[bind]] + key = "a" + finalKey = false + command = "master-key.prefix" + args.cursor = "Block" + doc.name = "explicit prefix" + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert_eq!(result.key_bind.len(), 2); + if let BindingOutput::Do { + key, + args: BindingOutputArgs { prefix, .. }, + .. + } = &result.key_bind[0] + { + assert_eq!(key, "b"); + assert_eq!(prefix, "a"); + } else { + error!("Unexpected binding {:#?}", result.key_bind[0]); + assert!(false); + } + + if let BindingOutput::Do { + key, + args: BindingOutputArgs { prefix, name, .. }, + .. + } = &result.key_bind[1] + { + assert_eq!(key, "a"); + assert_eq!(prefix, ""); + assert_eq!(name, "explicit prefix") + } else { + error!("Unexpected binding {:#?}", result.key_bind[0]); + assert!(false); + } + } + + #[test] + fn output_bindings_identify_duplicates() { + let data = r#" + [[bind]] + key = "a k" + command = "bob" + + [[bind]] + key = "a k" + command = "allowed conditional" + when = "master-key.count > 0" + + [[bind]] + key = "a k" + command = "duplicate" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("Duplicate key")); + assert_eq!(report[0].range.start.line, 10); + assert_eq!(report[1].range.start.line, 1); + } + + #[test] + fn output_bindings_expand_prefixes() { + let data = r#" + [[bind]] + key = "a b" + command = "foo" + prefixes = ["x y", "h k"] + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert_eq!(result.key_bind.len(), 8) + } + + // TESTS to implement: + // - [ ] detect duplicate bindings + // - [ ] expand prefixes + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) From 92b97011b5907bb80584c1808a92e888e275e486 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 4 Oct 2025 12:19:59 -0400 Subject: [PATCH 63/79] update notes Created using spr 1.3.6-beta.1 --- notes.md | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/notes.md b/notes.md index 62642ace..9098113f 100644 --- a/notes.md +++ b/notes.md @@ -253,15 +253,12 @@ Integration test debugging: something - [ ] unit tests for binding output generation - [ ] write `BindingOutput` to keybindings.json - - [ ] re-implement master-key.do + - [ ] re-implement master-key.do and master-key.prefix - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make sense) - [ ] move all bare variables in an expression to `key.` or `code.` object - - [ ] transfer scope state from TS to rust Scope object - - [ ] set a variable up to track the key code so that if `master-key.prefix` is - called it can use it to set the prefix (alternative you always set this - but we clear it when something isn't the final key) - - [ ] properly handle command queues (no controlled by rust) + - [ ] use rust scope instead of TS state object (update state.ts) + - [ ] properly handle command queues (now controlled by rust) - [ ] guess: don't have special command queue field - [ ] support accessing values by their path (`val.foo`, `key.count`) from javascript From 6b20153ed18017da570322ba8829c7a21799d166 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 4 Oct 2025 20:33:59 -0400 Subject: [PATCH 64/79] working `all_prefixes` Created using spr 1.3.6-beta.1 --- notes.md | 33 +++++------ src/rust/parsing/src/bind.rs | 90 ++++++++++++++++++++++++++++- src/rust/parsing/src/expression.rs | 2 + src/rust/parsing/src/file.rs | 92 ++++++++++++++++++++++++++++-- 4 files changed, 196 insertions(+), 21 deletions(-) diff --git a/notes.md b/notes.md index 9098113f..dcc496c3 100644 --- a/notes.md +++ b/notes.md @@ -214,36 +214,37 @@ Integration test debugging: - [X] replace `editorTextFocus` with check for palette context - [X] no duplicate keybindings: hash each key prefix & mode & when-clause - [X] create a map of valid prefixes - - [ ] implement the `all` functions: - - [ ] `{{all_prefixes()}}` - - [ ] implement method to get statically prefixes - - [ ] implement validation check to prevent the definition of *new* + - [X] implement the `all` functions: + - [X] `{{all_prefixes()}}/{{not_prefixes(["not_me"])}}` + - [X] implement method to get statically prefixes + - [X] implement validation check to prevent the definition of *new* prefixes in an expression - - [ ] register a function for getting `all_prefixes` - - [ ] `{{not_prefixes()}}` + - [X] register a function for getting `all_prefixes` and `not_prefixes` + - [X] unit test - [X] `{{all_modes()}}` - [X] `{{not_modes(["not_me", "or_me"])}}` - - [ ] documentation expansion/validation across all `[[bind]]` values - with the same key and mode - e.g. merge all shared documentation across the shared names + - [ ] documentation expansion/validation + - across all `[[bind]]` values with the same key and mode + - across all combined bindings - [ ] find low hanging fruit for problems with using 1.0 files / bad fields - - [ ] implement tooling to use different levels (warn/info) + - [X] implement tooling to use different levels (warn/info) in error reporting - [ ] fields that exist in the old but not new (use `#[serde(flatten)]`) - [ ] add hints for fields that don't exist anywhere as well (probably as a hint or something) - [ ] review strings for single `{}` braces and warn that `{{}}` are now required - [ ] others? - - [ ] implement `[[kind]]` (or redesign) - - [ ] remove spurious line/char positions from expression error messages - - NOTE: these come from the line and char position in the rhai expression - which has nothing to do with the line and char position in the parent - keybinding file - - [ ] implement `[header]` section + - [ ] implement `[[kind]]` (or redesign) + - [ ] implement `[header]` section - [ ] instead of using `.mk.toml`, look for a specific heading in the file + - [ ] remove spurious line/char positions from expression error messages + - NOTE: these come from the line and char position in the rhai expression + which has nothing to do with the line and char position in the parent + keybinding file - [ ] error handling checks - [ ] make sure a range is always provided - [ ] test that all error messages show up when expected + - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) - [X] encode prefixes as prefixCode in when clause diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index a82cf1d5..309f0d9f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -5,9 +5,10 @@ use core::ops::Range; use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; +use rhai::{EvalAltResult, ImmutableString}; use serde::{Deserialize, Serialize}; -use std::collections::HashMap; use std::collections::hash_map::{Entry, OccupiedEntry}; +use std::collections::{HashMap, HashSet}; use std::convert::identity; use std::iter::Iterator; use toml::Spanned; @@ -243,6 +244,73 @@ impl BindingInput { doc: self.doc.clone(), }; } + + pub(crate) fn add_to_scope( + inputs: &Vec>, + scope: &mut Scope, + ) -> ResultVec<()> { + let mut all_prefixes = HashSet::new(); + for input in inputs { + if let TypedValue::Constant(prefixes) = input.as_ref().prefixes.as_ref() { + let explicit_prefixes: Vec = + prefixes.clone().resolve("prefixes", scope).unwrap(); + let key_sequence: String = input.as_ref().key.clone().resolve("`key`", scope)?; + if explicit_prefixes.len() > 0 { + for p in explicit_prefixes { + let seq = WHITESPACE.split(&p).chain(WHITESPACE.split(&key_sequence)); + for s in list_prefixes(seq) { + all_prefixes.insert(s.join(" ")); + } + } + } else { + let seq = WHITESPACE.split(&key_sequence); + let prefixes = list_prefixes(seq); + for s in prefixes[0..(prefixes.len() - 1)].iter() { + all_prefixes.insert(s.join(" ")); + } + }; + } + } + + scope.prefixes = all_prefixes; + let all_prefixes_fn_data = scope.prefixes.clone(); + scope.engine.register_fn("all_prefixes", move || { + all_prefixes_fn_data + .iter() + .map(|x| rhai::Dynamic::from(ImmutableString::from(x))) + .collect::() + }); + + let not_prefixes_fn_data = scope.prefixes.clone(); + scope.engine.register_fn( + "not_prefixes", + move |x: rhai::Array| -> std::result::Result> { + let not_prefixes = x + .into_iter() + .map(|xi| xi.into_immutable_string()) + .collect::, _>>()?; + let mut result = rhai::Array::new(); + for prefix in ¬_prefixes_fn_data { + if not_prefixes.iter().all(|x| x != prefix) { + result.push(rhai::Dynamic::from(ImmutableString::from(prefix))); + } + } + if result.len() == (¬_prefixes_fn_data).len() { + let mut bad_prefix = None; + for prefix in not_prefixes { + if (¬_prefixes_fn_data).iter().all(|x| x != prefix) { + bad_prefix = Some(prefix); + break; + } + } + return Err(format!("prefix `{}` does not exist", bad_prefix.unwrap()).into()); + } + return Ok(result); + }, + ); + + return Ok(()); + } } impl Merging for BindingInput { @@ -679,6 +747,26 @@ impl Binding { .with_range(&mode_span)?; } + // prefix validation + let prefixes_span = input.prefixes.span().clone(); + let prefixes: Vec = input.prefixes.clone().resolve("prefixes", scope)?; + let non_static_prefixes: Vec<_> = prefixes + .iter() + .filter(|x| !scope.prefixes.contains(x.as_str())) + .collect(); + if non_static_prefixes.len() > 0 { + return Err(err!( + "Prefixes must be statically defined, but some prefixes \ + were only defined within expression blocks: `{}`", + non_static_prefixes + .iter() + .map(|x| x.as_str()) + .collect::>() + .join("`, `") + )) + .with_range(&prefixes_span)?; + } + // require that bare keybindings (those without a modifier key) // be specific to `textEditorFocus` / `keybindingPaletteOpen` context let key_string: String = resolve!(input, key, scope)?; diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 7170e9e7..07f1c0b8 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -116,6 +116,7 @@ use crate::{ pub struct Scope { pub(crate) asts: HashMap, pub(crate) engine: rhai::Engine, + pub(crate) prefixes: HashSet, pub(crate) modes: HashSet, pub(crate) default_mode: String, pub(crate) state: rhai::Scope<'static>, @@ -183,6 +184,7 @@ impl Scope { engine: engine, state: rhai::Scope::new(), default_mode: "default".to_string(), + prefixes: HashSet::from(["".to_string()]), modes: HashSet::from(["default".to_string()]), queues: HashMap::new(), }; diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 23669174..028f4d73 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -157,6 +157,7 @@ impl KeyFile { }; define.add_to_scope(&mut scope)?; + BindingInput::add_to_scope(&bind_input, &mut scope)?; let _ = scope .parse_asts(&bind_input) .map_err(|mut es| errors.append(&mut es.errors)); @@ -637,6 +638,93 @@ mod tests { assert_eq!(report[0].range.start.line, 14) } + #[test] + fn eval_prefix_expressions() { + let data = r#" + [[bind]] + key = "a b c" + command = "foo" + + [[bind]] + key = "d e f" + command = "bar" + + [[bind]] + key = "z" + command = "biz" + prefixes = '{{all_prefixes()}}' + + [[bind]] + key = "w" + command = "baz" + prefixes = '{{not_prefixes(["d e"])}}' + "#; + + let mut scope = Scope::new(); + let result = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + assert!(result.bind[2].prefixes.iter().any(|x| x == "a")); + assert!(result.bind[2].prefixes.iter().any(|x| x == "a b")); + assert!(result.bind[2].prefixes.iter().any(|x| x == "d")); + assert!(result.bind[2].prefixes.iter().any(|x| x == "d e")); + assert_eq!(result.bind[2].prefixes.len(), 4); + assert!(result.bind[3].prefixes.iter().any(|x| x == "a")); + assert!(result.bind[3].prefixes.iter().any(|x| x == "a b")); + assert!(result.bind[3].prefixes.iter().any(|x| x == "d")); + assert_eq!(result.bind[3].prefixes.len(), 3); + } + + #[test] + fn validate_prefix_expressions() { + let data = r#" + [[bind]] + key = "a b c" + command = "foo" + + [[bind]] + key = "d e f" + command = "bar" + + [[bind]] + key = "w" + command = "baz" + prefixes = '{{not_prefixes(["d k"])}}' + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("prefix `d k`")); + assert_eq!(report[0].range.start.line, 12) + } + + #[test] + fn validate_prefixes_are_static() { + let data = r#" + [[bind]] + key = "a b c" + command = "foo" + + [[bind]] + key = "d e f" + command = "bar" + + [[bind]] + key = "w" + command = "baz" + prefixes = '{{["d e", "g h"]}}' + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + info!("report: {report:#?}"); + assert!(report[0].message.contains("statically defined")); + assert_eq!(report[0].range.start.line, 12) + } + #[test] fn command_expansion() { let data = r#" @@ -844,10 +932,6 @@ mod tests { assert_eq!(result.key_bind.len(), 8) } - // TESTS to implement: - // - [ ] detect duplicate bindings - // - [ ] expand prefixes - // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) From 3ff16c7d5789ccc988bb8eda47327dc583b296ae Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 6 Oct 2025 17:03:17 -0400 Subject: [PATCH 65/79] checks for legacy file format Created using spr 1.3.6-beta.1 --- notes.md | 16 +- old_format/larkin.toml | 3534 ++++++++++++++++++++++++++ old_format/parsing.ts | 459 ++++ src/extension/commands/namedStore.ts | 4 +- src/rust/parsing/src/bind.rs | 165 +- src/rust/parsing/src/expression.rs | 6 +- src/rust/parsing/src/file.rs | 160 +- 7 files changed, 4324 insertions(+), 20 deletions(-) create mode 100644 old_format/larkin.toml create mode 100644 old_format/parsing.ts diff --git a/notes.md b/notes.md index dcc496c3..bce961e1 100644 --- a/notes.md +++ b/notes.md @@ -223,21 +223,16 @@ Integration test debugging: - [X] unit test - [X] `{{all_modes()}}` - [X] `{{not_modes(["not_me", "or_me"])}}` - - [ ] documentation expansion/validation - - across all `[[bind]]` values with the same key and mode - - across all combined bindings - [ ] find low hanging fruit for problems with using 1.0 files / bad fields - [X] implement tooling to use different levels (warn/info) in error reporting - - [ ] fields that exist in the old but not new (use `#[serde(flatten)]`) - - [ ] add hints for fields that don't exist anywhere as well (probably - as a hint or something) + - [~] fields that exist in the old but not new (use `#[serde(flatten)]`) - [ ] review strings for single `{}` braces and warn that `{{}}` are now required - [ ] others? - [ ] implement `[[kind]]` (or redesign) - - [ ] implement `[header]` section + - [ ] implement `[header]` section - [ ] instead of using `.mk.toml`, look for a specific heading in the file - - [ ] remove spurious line/char positions from expression error messages + - [ ] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression which has nothing to do with the line and char position in the parent keybinding file @@ -267,13 +262,16 @@ Integration test debugging: - [ ] integration tests - [ ] implement `replay`: use the new rust command queues instead of the old state management - - [ ] extraction of visual docs - [ ] extraction of markdown docs + - [ ] documentation expansion/validation + - across all `[[bind]]` values with the same key and mode + - across all combined bindings - [ ] extract all comment regions (exclude `#-`) - [ ] replace `[[bind]]` regions: - [ ] identify each non-comment region, and look for parsed elements whose span overlaps - [ ] convert any bind elements in this overlap into markdown table + - [ ] extraction of visual docs - [ ] serialization of bindings to settings.json - [ ] create data types to generate warnings/hints for old/unused fields - [ ] test this on the old version of larkin.toml diff --git a/old_format/larkin.toml b/old_format/larkin.toml new file mode 100644 index 00000000..479d38a7 --- /dev/null +++ b/old_format/larkin.toml @@ -0,0 +1,3534 @@ +# --- +# author: David Little +# license: MIT https://github.com/haberdashPI/vscode-master-key/blob/main/LICENSE.md +# --- + +# # Master Keybindings: Larkin + +# Larkin is the default keybinding set that ships with Master Key. It follows in the footsteps of Vim, Kakoune and Helix. This is the version of Larkin that uses a layout dependent keymap. + +# Some key features: + +# - Commands are modal: most actions are available in `normal` mode, while typing occurs in `insert` mode +# - Command are organized around noun-verb ordering: e.g. `w` selects a word, and `d` will then delete it. +# - Selection is sticky: once a selection is created, further commands tend to extend that selection until it is reset (using `v`). However a number of commands are defined to automatically reset the selection (e.g. `mw` creates a new selection around a word). + +# +# These bindings are named after the middle name of my first child (Larkin). + +# +# > ℹ **Info**: If your needs require a layout independent keymap consider changing "Use Layout Independent Bindings" in settings to true. It will transform all bindings to use the layout independent versions of the keys. For example the binding for `w` will be transformed to `[KeyW]`, which corresponds to the location of the letter "W" in the U.S. Keyboard layout. + +# + +#- NOTE: this file is used to generate both keybindings and to generate a markdown file that documents the bindings. When comments are prefixed with a `-` they are ignored in the final markdown output. All other comments will become part of the markdown output. Any [[bind]] entries unbroken by normal, markdown-displayed comments will show up in a table in the markdown output. Make sure that the normal comments do not break up TOML data in a way that means it is invalid TOML. + +[header] +name = "Larkin" +version = "1.0" + +requiredExtensions = [ + "dbankier.vscode-quick-select", + "haberdashPI.vscode-select-by-indent", + "haberdashPI.selection-utilities", + "pustelto.bracketeer", + "wmaurer.change-case", + "pkief.markdown-checkbox", + "jack89ita.open-file-from-path", + "koalamer.labeled-bookmarks", + "dnut.rewrap-revived", +] + +[[mode]] +name = "insert" +recordEdits = true + +[[mode]] +name = "normal" +default = true +highlight = "Highlight" +cursorShape = "Block" + +[[mode]] +name = "selectedit" +highlight = "Highlight" +cursorShape = "BlockOutline" + +[define] +select_on = false +around_on = false + +[[kind]] +name = "motion" +description = "These commands move the cursor and/or selections." + +[[kind]] +name = "action" +description = """ +Actions do something with the selected text (e.g. delete it). Unless otherwise noted, in +the absence of a selection, an action will modify an entire line, and a count argument +indicates the number of lines (e.g. 3d deletes this line and the next 3 lines). +""" + +[[kind]] +name = "util" +description = """ +Assorted other commands that aren't motions or actions +""" + +[[define.selectLinesDown]] +command = "selection-utilities.shrinkToActive" + +[[define.selectLinesDown]] +if = "count" +command = "cursorMove" +args = { to = "down", by = "wrappedLine", select = true } +computedArgs = { value = "count" } + +[[define.selectLinesDown]] +command = "expandLineSelection" + +[[define.selectLinesUp]] +command = "selection-utilities.shrinkToActive" + +[[define.selectLinesUp]] +if = "count" +command = "cursorMove" +args = { to = "up", by = "wrappedLine", select = true } +computedArgs = { value = "count" } + +[[define.selectLinesUp]] +command = "expandLineSelection" + + +[[path]] +id = "modes" +name = "Modes" +default.kind = "util" + +# ## Getting Help + +# There are three kinds of help available in Master Key. + +# 1. The visual documentation shows up in the lower pane and shows the currently available bindings on-top of a keyboard layout. +# 2. The text documentation is what you are reading now. +# 3. The suggestion palette shows a list of the current bindings given the current key binding prefix. + +[[bind]] +path = "util" +key = "shift+;" +name = "suggest" +resetTransient = false +hideInPalette = true +prefixes = [] +mode = ["!capture", "!insert"] +description = """ +show command suggestions within the context of the current mode and keybinding prefix (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that start with `TAB`. +""" +command = "master-key.commandSuggestions" + +[[bind]] +key = "tab /" +name = "text docs" +priority = -1 +mode = "normal" +description = "Show text documentation for keybindings" +command = "master-key.showTextDoc" + +[[bind]] +key = "tab shift+/" +name = "visual doc" +priority = -1 +mode = "normal" +description = "Show visual documentation for keybindings" +command = "master-key.showVisualDoc" + +# The visual keybinding documentation is modified by three additional commands that can be used to determine which modifiers are shown. + +# - `Master Key: Toggle Visual Doc Modifier by frequency`: changes keybinding modifiers from most to least common modifiers across all modifiers defined by the current keybindings. + +# +# There are no keybindings for these commands by default. + +# ## Normal Mode + +# The default mode in Larkin is Normal mode. In this mode, instead of the keys entering text, all keys are commands that modify selections or perform actions on those selections. To exit normal mode you can use `i` to enter `insert` mode, which returns VSCode keybindings to their normal state (see [Simple actions](#simple-actions) for more ways to enter insert mode). + +# While in Normal model you will see a highlighted section with the text "normal" in the lower left hand corner of the status bar. + +[[bind]] +path = "modes" +name = "normal" +description = "Enter normal mode" +foreach.key = ["escape", "ctrl+["] +combinedKey = "escape/ctrl+[" +combinedName = "normal" +combinedDescription = "Enter normal mode" +key = "{key}" +mode = [] +hideInPalette = true +hideInDocs = false +command = "master-key.enterNormal" +when = "!findWidgetVisible" +prefixes = "" + +[[bind]] +path = "modes" +name = "normal" +foreach.key = ["escape", "ctrl+["] +key = "{key}" +hideInPalette = true +hideInDocs = true +when = "suggestWidgetVisible && editorTextFocus && !findWidgetVisible" +command = "runCommands" +args.commands = ["hideSuggestWidget", "master-key.enterNormal"] +mode = [] +prefixes = "" + +#- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect +[[bind]] +path = "modes" +name = "ignore" +description = "this key does nothing" +foreach.key = ['{key: .}', 'shift+{key: .}'] #- all keys whose bindings are described by a single character +key = "{key}" +command = "master-key.ignore" +prefixes = "" +mode = ["normal", "selectedit"] +when = "editorTextFocus" +hideInDocs = true +hideInPalette = true +priority = -10 + +[[path]] +id = "edit" +name = "Editor Commands" +when = "editorTextFocus && !findWidgetVisible" +default.mode = "normal" + +[[path]] +id = "edit.count" +name = "count" +default.kind = "count" + +# ## Basic motions + +# These are the most common, simple motions that can be performed in Larkin. + +# Selection behavior uses the following logic: motions that move more than one character generally select the text "under" the motion. If a selection already exists (e.g. from a previous motion) additional motions extend that selection. You can always reset the selection using `v`, and several commands (e.g. `x`) operate on the next character rather than the current selection. + +[[path]] +id = "edit.motion" +name = "Motions" +description = "Commands that move the cursors and/or selections" +default.kind = "motion" + +[[path]] +id = "edit.motion.prim" +name = "Primitive Motions" +description = "Motions fundamental to moving around in the editor." +default.command = "cursorMove" +default.computedArgs.value = "count" +default.computedArgs.select = "editorHasSelection || select_on" + +[[bind]] +path = "edit.motion.prim" +key = "h" +name = "←" +combinedName = "←/→" +combinedKey = "h/l" +combinedDescription = "move left/right" +description = "move left" +args.to = "left" +mode = "normal" + +[[bind]] +path = "edit.motion.prim" +key = "l" +combinedName = "←/→" +name = "→" +description = "move right" +args.to = "right" + +[[bind]] +path = "edit.motion.prim" +key = "j" +name = "↓" +combinedName = "↓/↑" +combinedKey = "j/k" +combinedDescription = "move down/up" +description = "move down" +args.to = "down" +args.by = "wrappedLine" + +[[bind]] +path = "edit.motion.prim" +key = "k" +name = "↑" +description = "move up" +combinedName = "↓/↑" +args.to = "up" +args.by = "wrappedLine" + +[[bind]] +path = "edit.motion.prim" +key = "shift+h" +name = "start" +description = "start of line (alternates between first non-white and first)" +combinedName = "start/end" +combinedKey = "shift+h/shift+l" +combinedDescription = "move to start/end of line" +command = "cursorHomeSelect" + +[[bind]] # we don't use prim because we don't want the defaults +path = "edit.motion" +key = "shift+l" +name = "end" +combinedName = "start/end" +description = "end of line" +command = "cursorMove" +args.to = "wrappedLineEnd" +args.select = true + +[[bind]] +path = "edit.motion.prim" +key = "shift+k" +name = "sel ↑" +combinedName = "sel ↑/↓" +combinedDescription = "select lines up/down" +combinedKey = "shift+k/shift+j" +description = "select lines upwards" +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "up", by = "wrappedLine", select = true } +computedArgs = { value = "count" } + +[[bind.args.commands]] +command = "expandLineSelection" + +[[bind.args.commands]] +command = "selection-utilities.exchangeAnchorActive" + +[[bind]] +path = "edit.motion.prim" +key = "shift+j" +name = "sel ↓" +combinedName = "sel ↑/↓" +description = "select lines downwards" +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "down", by = "wrappedLine", select = true } +computedArgs = { value = "count" } + +[[bind.args.commands]] +command = "expandLineSelection" + +[[bind]] +path = "edit.motion.prim" +key = "ctrl+d" +mode = ["normal", "insert"] +name = "pg ↓" +combinedName = "pg ↓/↑" +combinedKey = "ctrl+d/ctrl+u" +combinedDescription = "move down/up, relative to page size" +description = "move down, relative to page size" +command = "selection-utilities.activePageMove" +args.dir = "down" +computedArgs.count = "(count || 1)/3" +computedArgs.select = "mode == 'normal'" + +[[bind]] +path = "edit.motion.prim" +key = "ctrl+u" +mode = ["normal", "insert"] +name = "pg ↑" +combinedName = "pg ↓/↑" +description = "move up, relative to page size" +command = "selection-utilities.activePageMove" +args.dir = "up" +computedArgs.count = "(count || 1)/3" +computedArgs.select = "mode == 'normal'" + +[[bind]] +path = "edit.motion.prim" +key = "shift+x" +name = "exapand" +description = "expand selections to full lines" +command = "expandLineSelection" +repeat = "count" + +[[path]] +id = "edit.motion.obj" +name = "Motions defined by various regex and syntactical objects" +description = """ +motions that move by a predefined syntactic object (e.g. word, paragraph, etc...) +""" +default.command = "selection-utilities.moveBy" +default.args.boundary = "start" +default.args.select = true + +[[bind]] +path = "edit.motion.obj" +key = "w" +name = "subwrd →" +description = "next subword (camel/snake case)" +combinedName = "subwrd ←/→" +combinedDescription = "next/prev subword (camel/snake case)" +combinedKey = "w/b" +args.unit = "subword" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "b" +name = "subwrd ←" +description = "previous subword (camel/snake case)" +combinedName = "subwrd ←/→" +args.unit = "subword" +computedArgs.value = "-count || -1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+w" +name = "word →" +description = "next word" +combinedName = "word ←/→" +combinedDescription = "next/prev word" +combinedKey = "shift+w/b" +args.unit = "word" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+b" +name = "word ←" +combinedName = "word ←/→" +description = "previous word" +prefixes = [""] +args.unit = "word" +computedArgs.value = "-count || -1" + +[[bind]] +path = "edit.motion.obj" +key = "e" +name = "subwrd end" +description = "next subword (camel/snake case) end" +args.unit = "subword" +args.boundary = "end" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+e" +name = "word end" +description = "next word end" +args.unit = "word" +args.boundary = "end" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+]" +name = "parag. →" +description = "next paragraph" +combinedName = "paragraph →/←" +combinedDescription = "next/previous paragraph" +combinedKey = "shift+]/[" +args.unit = "paragraph" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+[" +name = "parag. ←" +combinedName = "paragraph →/←" +description = "previous paragraph" +args.unit = "paragraph" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.obj" +key = "shift+0" +name = "subsec →" +description = "next subsection" +combinedName = "subsec →/←" +combinedDescription = "next/previous subsection" +combinedKey = "shift+0/9" +args.unit = "subsection" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "shift+9" +name = "subsec ←" +description = "previous subsection" +combinedName = "subsec →/←" +args.unit = "subsection" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.prim" +key = "v" +name = "shrink selection" +combinedName = "shrink/hold selection" +combinedDescription = """ +reduce selections to zero length / make all commands extend the selection +""" +description = """ +reduce all selections to length zero +""" +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "master-key.setFlag", args = { name = "select_on", value = false } }, +] + +[[bind]] +path = "edit.motion.mod" +key = "shift+v" +name = "hold selection" +combinedName = "shrink/hold selection" +description = """ +all motions extend the selection +""" +command = "master-key.setFlag" +args.name = "select_on" +args.value = true + +[[bind]] +path = "edit.action.open_lines" +name = "open, act →" +description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" +key = "o" +combinedName = "open below/above, act →/←" +combinedKey = "o/shift+o" +combinedDescription = """ +without selection: open a line below/above current line and enter insert, with selection: move cursor to end/start +of selection +""" +when = "!editorHasSelection" +command = "runCommands" +args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] + +[[bind]] +path = "edit.action.open_lines" +key = "o" +combinedName = "open below/above, act →/←" +when = "editorHasSelection" +command = "selection-utilities.activeAtEnd" + +[[bind]] +path = "edit.action.open_lines" +name = "open blw, act ←" +combinedName = "open below/above, act →/←" +description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" +key = "shift+o" +when = "!editorHasSelection" +command = "runCommands" +args.commands = [ "editor.action.insertLineBefore", "master-key.enterInsert" ] + +[[bind]] +path = "edit.action.open_lines" +name = "open blw, act ←" +combinedName = "open below/above, act →/←" +description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" +key = "shift+o" +when = "editorHasSelection" +command = "selection-utilities.activeAtStart" + +[[bind]] +path = "edit.motion" +key = "shift+5" +name = "to bracket" +description = "Move to matching bracket" +command = "editor.action.jumpToBracket" + +[[bind]] +path = "edit.motion.prim" +key = '\' +name = "→ sel" +combinedName = "→/← sel" +description = "select *just* the character to the right" +combinedDescription = "select *just* the character to the right" +combinedKey = 'shift+\/\' +mode = ["normal", "selectedit"] +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "right", select = true } +computedArgs = { value = "count" } + +[[bind]] +path = "edit.motion.prim" +key = 'shift+\' +name = "← sel" +combinedName = "→/← sel" +description = "select *just* the character to the left" +mode = ["normal", "selectedit"] +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "left", select = true } +computedArgs = { value = "count" } + +[[path]] +id = "edit.motion.mod" +name = "Modify Motion Effects" +description = "Keys that change how other motions work" +default.kind = "motion" + +[[bind]] +path = "edit.motion.obj" +key = "shift+4" +name = "all" +description = "Select entire document" +command = "editor.action.selectAll" + +[[bind]] +path = "edit.motion" +key = "shift+r" +name = "trim wht" +description = "trim external whitespace" +command = "selection-utilities.trimSelectionWhitespace" + +[[bind]] +path = "edit.motion.obj" +name = "→ num." +description = "Move to next number" +key = "shift+3" +combinedName = "→/← num." +combinedDescription = "Move to next/prev number" +combinedKey = "shift+3/2" +args.unit = "number" +args.selectWhole = true +args.boundary = "both" +computedArgs.value = "(count || 1)" + +[[bind]] +path = "edit.motion.obj" +name = "← num." +description = "Move to next number" +key = "shift+2" +combinedName = "→/← num." +args.unit = "number" +args.selectWhole = true +args.boundary = "both" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion" +name = 'narrow to subword' +description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" +key = "z" +command = "selection-utilities.narrowTo" +args.unit = "subident" +args.boundary = "both" + +# ## Repeating Motions + +# Like VIM, the number keys (0-9) can be typed as a prefix to most commands and serve as a `count` +# argument to that command. In most cases this causes the command to be repeated `count` +# times e.g. 2w would select the next two words starting from the current cursor position. + +[[bind]] +path = "edit.count" +foreach.num = ['{key: [0-9]}'] +name = "count {num}" +key = "{num}" +command = "master-key.updateCount" +description = "Add digit {num} to the count argument of a command" +combinedKey = "0-9" +combinedName = "count 0-9" +combinedDescription = "Add digit 1-9 to count argument of a command" +args.value = "{num}" +resetTransient = false +mode = ["!insert", "!capture"] +hideInDocs = true + +# There are several ways to repeat or undo previously entered commands, both actions and motions + +[[path]] +id = "edit.motion.history" +name = "motion history" +description = "Commands that repeat some kind of motion" + +[[bind]] +path = "edit.motion.history" +key = ";" +name = "repeat motion" +description = """ +Repeat the last motion command. Motions usually move the cursor or change the selection. +""" +repeat = "count" +command = "master-key.replayFromHistory" +args.at = """ +commandHistory[i].path.startsWith('edit.motion') && +commandHistory[i].name != 'repeat motion' && +commandHistory[i].name != 'shrink selection' +""" + +[[bind]] +path = "edit.motion.history" +name = "repeat subject" +description = """ +Repeat the subject: a motion command that occurred right before an action. For +instance `w` followed by `d` selects a word and deletes it. The `w` command would be the +last subject until some new action is run after `d`. See also `.` which repeats the last action. +""" +key = "," +command = "master-key.replayFromHistory" +args.at = """ +commandHistory[i].path.startsWith("edit.motion") && +commandHistory[i+1].path.startsWith("edit.action") && +!(commandHistory[i+1].name.startsWith("repeat ") && + commandHistory[i+1].path.startsWith("edit.action.history")) +""" + +[[bind]] +path = "edit.motion.history" +name = "cursor undo" +key = "-" +combinedName = "cursor undo/redo" +combinedKey = "-/shift+-" +command = "cursorUndo" + +[[bind]] +path = "edit.motion.history" +name = "cursor redo" +combinedName = "cursor undo/redo" +key = "shift+-" +command = "cursorRedo" + +[[bind]] +path = "edit.motion.history" +name = "nav ←" +description = "Go back in navigation history (e.g. goto definition)" +combinedName = "nav ←/→" +combinedKey = "n/shift+n" +combinedDescription = "Go back/forward in navigation history" +key = "g n" +command = "workbench.action.navigateBackInNavigationLocations" + +[[bind]] +path = "edit.motion.history" +name = "nav →" +combinedName = "nav ←/→" +description = "Go forward in navigation history (e.g. goto definition)" +key = "g shift+n" +command = "workbench.action.navigateForwardInNavigationLocations" + +[[bind]] +path = "edit.motion.history" +name = "edit hist ←" +description = "Go back in edit history" +key = "g -" +combinedName = "edit ←/→" +combinedKey = "-/shift+-" +combinedDescription = "Go back/forward in edit history" +command = "workbench.action.navigateBackInEditLocations" + +[[bind]] +path = "edit.motion.history" +name = "edit hist →" +description = "Go forward in edit history)" +key = "g shift+-" +combinedName = "edit ←/→" +command = "workbench.action.navigateForwardInEditLocations" + +# ## Search Motions + +# Search motions accept one or more characters and select text up until the given character. Search commands are case insensitive by default. They can serve as very efficient ways to jump to a desired location. E.g. typing `sfod` in normal mode would delete the first three words of the following line of text +# +# > I want some food + +[[path]] +id = "edit.motion.search" +name = "Search Related Motions" +description = "Motions related to searching for text in a document" +default.command = "master-key.search" +default.args.caseSensitive = false +default.args.backwards = false +default.args.selectTillMatch = true +default.args.wrapAround = true + +[[bind]] +path = "edit.motion.search" +key = "/" +name = "search →" +description = "search forwards" +combinedName = "search → (←)" +combinedDescription = "search forwards (backwards)" +combinedKey = "/ (shift+/)" +args.offset = "start" +args.register = "search" + +[[bind]] +path = "edit.motion.search" +key = "shift+/" +name = "search ←" +description = "search backwards" +combinedName = "search → (←)" +args.offset = "start" +args.register = "search" +args.backwards = true + +[[bind]] +path = "edit.motion.search" +key = "n" +name = "→ search" +description = "Go to the next match of the search query" +command = "master-key.nextMatch" +args.register = "search" +computedArgs.repeat = "(count || 1)-1" + +[[bind]] +path = "edit.motion.search" +key = "shift+n" +name = "← search" +description = "Go to the previous match of the search query" +command = "master-key.previousMatch" +args.register = "search" +computedArgs.repeat = "(count || 1)-1" + +[[bind]] +path = "edit.motion.search" +key = "shift+8" +name = "match →" +description = "Next match to object under cursor" +combinedName = "match →/←" +combinedDescription = "Next/previous match to object under cursor" +combinedKey = "shift+8/7" +computedArgs.text = "firstSelectionOrWord" +args.offset = "start" +args.register = "search" + +[[bind]] +path = "edit.motion.search" +key = "shift+7" +name = "match ←" +description = "Previous match to object under cursor" +combinedName = "match →/←" +computedArgs.text = "firstSelectionOrWord" +args.offset = "start" +args.register = "search" +args.backwards = true + +[[bind]] +path = "edit.motion.search" +key = "f" +name = "find char" +description = "Find the next char (include char in selection)" +combinedName = "find char (back)" +combinedDescription = "Find the next (previous) char (include char in selection)" +combinedKey = "f (shift+f)" +args.acceptAfter = 1 +computedArgs.skip = "count-1" +args.offset = "inclusive" + +[[bind]] +path = "edit.motion.search" +key = "shift+f" +name = "find char back" +description = "Find the previous char (include char in selection)" +combinedName = "find char (back)" +args.acceptAfter = 1 +args.offset = "inclusive" +args.backwards = true +computedArgs.skip = "count-1" + +[[bind]] +path = "edit.motion.search" +key = "t" +name = "to char" +description = "Find the next char (exclude char in selection)" +combinedName = "to char (back)" +combinedKey = "t (shift+t)" +combinedDescription = "Find the next/previous char (exclude char in selection)" +args.acceptAfter = 1 +args.offset = "start" +computedArgs.skip = "count-1" + +[[bind]] +path = "edit.motion.search" +key = "shift+t" +name = "to char back" +description = "Find the previous char (exclude char in selection)" +combinedName = "to char (back)" +args.acceptAfter = 1 +args.offset = "end" +args.backwards = true +computedArgs.skip = "count-1" + +[[bind]] +path = "edit.motion.search" +key = "s" +name = "find char pair" +description = "To next character pair" +combinedName = "char pair →/←" +combinedDescription = "To next character pair" +combinedKey = "s/shift+s" +args.acceptAfter = 2 +args.offset = "start" +computedArgs.skip = "count-1" +mode = "normal" + +[[bind]] +path = "edit.motion.search" +key = "shift+s" +name = "char pair back" +description = "To previous character pair" +combinedName = "char pair →/←" +args.acceptAfter = 2 +args.offset = "start" +computedArgs.skip = "count-1" +args.backwards = true + +# ## Goto Commands + +# Goto commands all begin with the mnemonic prefix key `g`. They are additional +# motion commands that compliment the basic motions listed in the previous section. + +[[bind]] +path = "edit.motion" +key = "g" +priority = 1 +name = "goto" +command = "master-key.prefix" +description = """ +Goto commands move the location of the cursor (or the active selection position) forward +or backwards in some direction. +""" + +[[bind]] +path = "edit.motion.prim" +key = "g j" +priority = 1 +name = "unwrp ↓" +combinedName = "unwrap ↓/↑" +combinedKey = "j/k" +combinedDescription = """ +move cursor up/down unwrapped text line; if a single line is wrapped into multiple lines by +the editor, this command skips all such wrapped lines +""" +description = """ +down unwrapped line; if a single line is wrapped into multiple lines by the editor, this +command skips all such wrapped lines +""" +args.to = "down" +args.by = "line" + +[[bind]] +path = "edit.motion.prim" +key = "g k" +priority = 1 +name = "unwrp ↑" +combinedName = "unwrap ↓/↑" +description = "up unwrapped line" +args.to = "up" +args.by = "line" + +[[bind]] +path = "edit.motion.prim" +key = "g shift+k" +priority = 1 +combinedName = "unwrp sel ↑/↓" +combinedDescription = "select unwrapped lines up/down" +combinedKey = "shift+k/j" +name = "unwrp sel ↑" +description = "select unwrapped lines upwards" +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "up", by = "line", select = true } +computedArgs = { value = "count" } + +[[bind.args.commands]] +command = "expandLineSelection" + +[[bind]] +path = "edit.motion.prim" +key = "g shift+j" +priority = 1 +name = "sel ↓" +combinedName = "unwrp sel ↑/↓" +description = "select unwrapped lines downwards" +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorMove" +args = { to = "down", by = "line", select = true } +computedArgs = { value = "count" } + +[[bind.args.commands]] +command = "expandLineSelection" + +[[bind]] +path = "edit.motion.prim" +key = "shift+g" +priority = 1 +name = "doc end" +description = "select to end of document" +combinedName = "doc top/bottom" +combinedDescription = "select to top/bottom of document" +combinedKey = ",/." +command = "cursorBottomSelect" + +[[bind]] +path = "edit.motion.prim" +key = "g g" +priority = 1 +name = "doc start" +description = "select to start (line) of document." +command = "runCommands" +when = "master-key.count > 1" + +[[bind.args.commands]] +command = "cursorTop" + +[[bind.args.commands]] +command = "cursorMove" +args.to = "down" +args.by = "wrappedLine" +computedArgs.value = "count-1" + +[[bind.args.commands]] +command = "revealLine" +args.at = "center" +computedArgs.lineNumber = "count" + +[[bind]] +path = "edit.motion.prim" +key = "g g" +priority = 1 +name = "doc start" +description = "select to start of document" +command = "cursorTopSelect" +when = "master-key.count <= 1" + +[[bind]] +path = "edit.motion.obj" +key = "g w" +priority = 1 +name = "WORD →" +combinedName = "WORD →/←" +combinedDescription = """ +next/prev WORD; e.g. contiguous non-whitespace region +""" +combinedKey = "w/b" +description = "next WORD; e.g. contiguous non-whitespace region" +args.unit = "BigWord" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "g b" +priority = 1 +name = "WORD ←" +combinedName = "WORD →/←" +description = "previous WORD; e.g. contiguous non-whitespace region" +args.unit = "BigWord" +computedArgs.value = "-count || -1" + +[[bind]] +path = "edit.motion.obj" +key = "g e" +priority = 1 +name = "WORD end →" +description = "next WORD end; e.g. contiguous non-whitespace region" +args.unit = "BigWord" +computedArgs.boundary = "around_on ? 'both' : 'end'" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "g 0" +priority = 1 +name = "sec →" +description = "next section" +combinedName = "sec →/←" +combinedDescription = "next/previous section" +combinedKey = "0/9" +args.unit = "section" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.obj" +key = "g 9" +priority = 1 +name = "sec ←" +description = "previous section" +combinedName = "sec →/←" +args.unit = "section" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "window" +name = "goto line" +priority = 1 +description = "goto line command" +key = "g l" +command = "workbench.action.gotoLine" +when = "editorTextFocus" + +[[bind]] +path = "window" +name = "to refs" +priority = 1 +description = "jump to a location where this symbol is referenced" +key = "g r" +command = "editor.action.goToReferences" +when = "editorTextFocus" + +[[bind]] +path = "window" +name = "go to" +priority = 1 +description = "go to the definition of symbol under cursor" +key = "g d" +combinedName = "go to (aside)" +combinedKey = "(shift+)d" +combinedDescription = "go to the definition of symbol (in an editor to the side)" +command = "editor.action.revealDefinition" +when = "editorTextFocus" + +[[bind]] +path = "window" +name = "go to, aside" +priority = 1 +description = "go to the definition of symbol under cursor in an editor to the side" +key = "g shift+d" +combinedName = "go to (aside)" +command = "editor.action.revealDefinitionAside" +when = "editorTextFocus" + +[[bind]] +path = "window" +name = "open" +description = "open the file name under the cursor" +key = "g f" +command = "extension.openFileFromPath" +when = "editorTextFocus" + +[[bind]] +path = "edit.motion" +key = "g c" +name = "cell →" +combinedName = "cell →/←" +command = "runCommands" +args.commands = [ "jupyter.gotoNextCellInFile", "jupyter.selectCell" ] +description = "previous jupyter notebook cell" + +[[bind]] +path = "edit.motion" +key = "g shift+c" +name = "cell ←" +combinedName = "cell →/←" +description = "previous jupyter notebook cell" +command = "runCommands" +args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] + +# ## Match Commands + +# Match commands select some syntactical region of text, e.g. in or around parenthesis, brackets, indent level etc... Where the `g` prefixed commands move forward or backward, these commands move both the start and the end of the selection away from the active cursor position. Repeating the command moves to the next (or previous) match, depending on the command. + +# If you accidentally select `around` instead of `in`, you can revise your selection using `R` to narrow to non-white space or `z` to narrow to a subword (e.g. excludes `_`) + +[[path]] +id = "edit.motion.match" +name = "Matching Motions" +description = "Motions that match some range of characters" + +[[path]] +id = "edit.motion.match.obj" +name = "Matching Object Motions" +description = "Motions that match some range of characters by predefined regex" +default.command = "selection-utilities.moveBy" +default.kind = "motion" +default.args.selectWhole = true +default.args.boundary = "start" + +[[bind]] +path = "edit.motion.match" +key = "m" +name = "match" +description = """ +Find the closest character range matching a specified object. +""" +kind = "motion" +command = "master-key.prefix" + +[[bind]] +path = "edit.motion.match" +key = "m m" +prefixes = [""] +name = "smart expand" +description = "Use VSCode's built-in smart expansion command" +command = "editor.action.smartSelect.expand" + +[[bind]] +path = "edit.motion.match.obj" +key = "m w" +name = "around subwrd →" +description = "(camel/snake case)" +combinedName = "around subwrd ←/→" +combinedDescription = "(camel/snake case)" +combinedKey = "w/b" +args.unit = "subword" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m b" +name = "around subwrd ←" +description = "(camel/snake case)" +combinedName = "around subwrd ←/→" +args.unit = "subword" +computedArgs.value = "-count || -1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+w" +name = "ard word →" +combinedName = "around word →/←" +combinedKey = "shift+w/b" +args.unit = "word" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+b" +name = "ard word ←" +combinedName = "around word →/←" +prefixes = [""] +args.unit = "word" +computedArgs.value = "-count || -1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m e" +name = "in subwrd" +combinedName = "in → subword/word" +combinedKey = "e/shift+e" +args.unit = "subident" +args.boundary = "both" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+e" +name = "in word" +combinedName = "in → subword/word" +args.unit = "word" +args.boundary = "both" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m p" +name = "in parag. →" +combinedName = "in paragraph →/←" +combinedKey = "p/o" +args.boundary = "both" +args.unit = "paragraph" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m o" +name = "in parag. ←" +combinedName = "in paragraph →/←" +args.unit = "paragraph" +args.boundary = "both" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+p" +name = "arn parag. →" +combinedName = "around paragraph →/←" +combinedKey = "shift+p/shift+o" +args.unit = "paragraph" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+o" +name = "arn parag. ←" +combinedName = "around paragraph →/←" +args.unit = "paragraph" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match.obj" +key = "m 0" +name = "arn subsec →" +combinedName = "around subsection →/←" +combinedKey = "0/shift+0" +args.unit = "subsection" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+0" +name = "arn subsec ←" +combinedName = "around subsection →/←" +args.unit = "subsection" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match.obj" +key = "m 9" +name = "in subsec →" +combinedName = "in subsection →/←" +combinedKey = "9/shift+9" +args.unit = "subsection" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m shift+9" +name = "in subsec ←" +combinedName = "in subsection →/←" +args.unit = "subsection" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match" +key = "m g" +name = "other..." +description = "additional objects to match..." +command = "master-key.prefix" + +[[bind]] +path = "edit.motion.match.obj" +key = "m g 0" +name = "section →" +combinedName = "section →/←" +combinedKey = "0/9" +args.unit = "section" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m g 9" +name = "section ←" +combinedName = "section →/←" +args.unit = "section" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match.obj" +key = "m g w" +name = "around WORD →" +combinedName = "around WORD →/←" +combinedKey = "w/b" +args.unit = "BigWord" +computedArgs.value = "count || 1" + +[[bind]] +path = "edit.motion.match.obj" +key = "m g b" +name = "around WORD ←" +combinedName = "around WORD →/←" +args.unit = "BigWord" +computedArgs.value = "-(count || 1)" + +[[bind]] +path = "edit.motion.match.obj" +key = "m g e" +name = "in WORD" +args.unit = "BigWord" +args.boundary = "both" +computedArgs.value = "count || 1" + +[[path]] +id = "edit.motion.match.syntax" +name = "Motions around syntactic objects (e.g. parentheses and quotes)" +description = """ +selection commands that move by a predefined syntactic object like brackets and quotes +""" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m [" +name = "in parens" +combinedName = "in/arnd parens" +combinedKey = "[/shift+[" +combinedDescription = """ +expand inside/around parens/brackets/braces and their contents; repeated calls to this command +will seek out larger and larger scopes +""" +description = """ +expand inside parens/brackets/braces and their contents; repeated calls to this command +will seek out larger and larger scopes +""" +command = "selection-utilities.expandWithinBrackets" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m shift+[" +name = "arnd parens" +combinedName = "in/arnd parens" +description = """ +expand inside parens/brackets/braces and their contents; repeated calls to this command +will seek out larger and larger scopes +""" +command = "selection-utilities.expandAroundBrackets" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m '" +name = "in quotes" +description = """ +select within current quotes; repeated calls to this command +will seek out larger and larger scopes +""" +combinedName = "in/arnd quotes" +combinedKey = "'/shift+'" +combinedDescription = """ +select within/around current quotes; repeated calls to this command +will seek out larger and larger scopes +""" +command = "bracketeer.selectQuotesContent" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m shift+'" +name = "around quotes" +combinedName = "in/arnd quotes" +description = """ +select around current quotes; repeated calls to this command +will seek out larger and larger scopes +""" +command = "runCommands" +args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesContent"] + +[[bind]] +path = "edit.motion.match.syntax" +key = "m shift+." +name = "in <>" +description = "text inside angle brackets" +combinedName = "in <> / in ><" +combinedKey = "shift+. / shift+," +combinedDescription = "text inside angle brackets / pairs (e.g. text in text)" +command = "extension.selectAngleBrackets" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m shift+," +name = "in ><" +combinedName = "in <> / in ><" +description = "text inside tag pairs (e.g. text)" +command = "extension.selectInTag" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m i" +name = "in indent" +description = "all text at the same indentation level" +combinedName = "in/arnd" +combinedKey = "space/shift+space" +combinedDescription = """ +all text at the same indentation level / all indentation along with the line above and +below this (ala c-like syntax) +""" +command = "vscode-select-by-indent.select-inner" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m shift+i" +name = "arnd indent" +description = """ +all text at the same indentation level along with the line above and below +this (ala c-like syntax) +""" +combinedName = "in/arnd" +command = "vscode-select-by-indent.select-outer" + +[[bind]] +path = "edit.motion.match.syntax" +key = "m g i" +name = "indent+top" +description = """ +all text at the same indentation level and the line just above it (ala python syntax) +""" +combinedName = "in/arnd" +command = "vscode-select-by-indent.select-outer-top-only" + +[[path]] +id = "edit.motion.match.cell" +name = "Matching Object Motions" +description = "Motions that match some range of characters by predefined regex" + +[[bind]] +path = "edit.motion.match.cell" +name = "in cell" +description = "select text within a cell (ala jupyter)" +key = "m c" +command = "jupyter.selectCell" + +[[path]] +id = "edit.motion.searchpair" +name = "Search pairs" +description = "Find text that falls between pairs of characters" + +[[bind]] +path = "edit.motion.searchpair" +name = "between pair" +combinedDescription = """ +Select between pairs of the same N characters (t) or distinct sets of N +characters (s), where N is the count. Examples: +2mt'' would search for a string between `''` and `''`. +2ms,,.. would search for a string between `,,` and `..`. +""" +key = "m t" +command = "runCommands" +combinedName = "between pair/two" +combinedKey = "t/s" +description = """ +Select between pairs of the same N characters, where N is the count. +Example: 2mt'' would search for a string between '' and ''. +""" + +[[bind.args.commands]] +command = "master-key.captureKeys" +computedArgs.acceptAfter = "count || 1" + +[[bind.args.commands]] +command = "selection-utilities.selectBetween" +computedArgs.str = "captured" +args.inclusive = false + +[[bind]] +path = "edit.motion.searchpair" +name = "between two" +description = """ +Select between two different sets of N characters, where N is the count e.g. +2ms,,.. would search for a string between ,, and .. +""" +key = "m s" +combinedName = "between pair/two" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.captureKeys" +computedArgs.acceptAfter = "2*(count || 1)" + +[[bind.args.commands]] +command = "selection-utilities.selectBetween" +computedArgs.between.from = "captured.slice(0, captured.length/2)" +computedArgs.between.to = "captured.slice(captured.length/2)" +args.inclusive = false + +# ## Simple Actions + +# These are the most common, basic actions available in Larkin that can be used +# to edit text in relation to the current selection. + +[[path]] +id = "edit.action" +name = "Actions" +description = "Commands that modify the document or UI" +default.kind = "action" +default.mode = "normal" + +[[path]] +id = "edit.action.basic" +name = "Basic Actions" +description = "Essential actions required to edit text" + +[[bind]] +path = "edit.action.basic" +#- TODO: add documentation to these basic editor keys +key = "i" +name = "insert" +description = "Switch to insert mode (right before character)" +command = "runCommands" +args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] +mode = ["normal", "selectedit", "syminsert"] + +[[bind]] +path = "edit.action.basic" +key = "a" +name = "append" +description = "insert after cursor" +mode = ["normal", "selectedit", "syminsert"] +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + "cursorRight", + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "shift+i" +name = "insert start" +mode = ["normal", "selectedit", "syminsert"] +command = "runCommands" +args.commands = [ + { command = "cursorMove", args = { to = "wrappedLineFirstNonWhitespaceCharacter", select = false } }, + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "shift+a" +name = "insert end" +mode = ["normal", "selectedit", "syminsert"] +command = "runCommands" +args.commands = [ + { command = "cursorMove", args = { to = "wrappedLineEnd", select = false } }, + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "c" +name = "change" +description = """ +Without a count: change selected region of text. With a count: +change up to `count` lines. +""" +when = "editorHasMultilineSelection" +command = "runCommands" +args.commands = ["deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert"] + +[[bind]] +path = "edit.action.basic" +key = "c" +when = "!editorHasMultilineSelection && editorHasSelection" +command = "runCommands" +args.commands = ["deleteRight", "master-key.enterInsert"] + +[[bind]] +path = "edit.action.basic" +key = "c" +when = "!editorHasSelection && master-key.count <= 1" +command = "runCommands" +args.commands = [ + "expandLineSelection", + "deleteRight", + "editor.action.insertLineBefore", + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "c" +when = "!editorHasSelection && master-key.count > 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "deleteRight", + "editor.action.insertLineBefore", + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "shift+c" +name = "change to/back" +description = """Without a count: change from current char to end of line. With a count: +change the previous `count` lines. +""" +mode = "normal" +when = "master-key.count <= 1" +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + "deleteAllRight", + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "shift+c" +mode = ["normal", "selectedit"] +when = "master-key.count > 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesUp" }, + "deleteRight", + "editor.action.insertLineBefore", + "master-key.enterInsert", +] + +[[bind]] +path = "edit.action.basic" +key = "x" +mode = "normal" +name = "delete char" +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "cursorMove", args = { to = "right", select = true }, computedArgs = { value = "count" } }, + "editor.action.clipboardCutAction" +] + +[[bind]] +path = "edit.action.basic" +key = "r" +name = "replace char" +description = "replace the character under the cursor" +command = "master-key.replaceChar" + +[[bind]] +path = "edit.action.basic" +key = "ctrl+i" +name = "insert char" +mode = ["normal", "selectedit"] +description = "insert a character in front of the cursor" +command = "master-key.insertChar" + +[[path]] +id = "edit.action.clipboard" +name = "Clipboard Operations" +description = "Operations that manipulate the clipboard in some way." + +[[bind]] +path = "edit.action.clipboard" +key = "p" +name = "paste after" +description = "Paste clipboard after the cursor/selection" +combinedName = "paste before/after/in" +combinedDescription = "Paste clipboard before/after/at the cursor/selection" +combinedKey = "p/shift+p/ctrl+p" +when = "editorHasSelection" +command = "runCommands" +args.commands = ["selection-utilities.activeAtEnd", "selection-utilities.shrinkToActive", "editor.action.clipboardPasteAction"] + +[[bind]] +path = "edit.action.clipboard" +key = "p" +name = "paste after" +combinedName = "paste before/after/in" +when = "!editorHasSelection" +command = "runCommands" +args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] + +[[bind]] +path = "edit.action.clipboard" +key = "ctrl+p" +when = "!suggestWidgetVisible" +mode = ["normal", "insert"] +name = "paste in" +combinedName = "paste before/after/in" +description = "Paste clipboard at location" +command = "editor.action.clipboardPasteAction" + +[[bind]] +path = "edit.action.clipboard" +key = "shift+p" +name = "paste before" +combinedName = "paste before/after" +description = "Paste before the cursor/selection" +when = "editorHasSelection" +command = "runCommands" +args.commands = ["selection-utilities.activeAtStart", "selection-utilities.shrinkToActive", "editor.action.clipboardPasteAction"] + +[[bind]] +path = "edit.action.clipboard" +key = "shift+p" +combinedName = "paste before/after" +when = "!editorHasSelection" +command = "runCommands" +args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] + +[[bind]] +path = "edit.action.history" +name = "repeat action" +description = """ +Repeat the last action command. Actions usually modify the text of a document in one way or +another. (But, e.g. sending text to the REPL is also considered an editor action). +See also `,` which repeats the last subject. +""" +key = "." +command = "runCommands" +repeat = "count" + +[[bind.args.commands]] +command = "master-key.replayFromHistory" +#- we can repeat any action but history-related actions; we make an exception for replaying macros, which can be repeated +args.at = """ +commandHistory[i].path.startsWith('edit.action') && +(!commandHistory[i].path.startsWith('edit.action.history') || + commandHistory[i].name == 'replay') +""" + +[[bind.args.commands]] +command = "master-key.enterNormal" + +[[bind]] +path = "edit.action.history" +name = "undo" +key = "u" +command = "runCommands" +args.commands = [ "undo", "selection-utilities.shrinkToActive" ] + +[[bind]] +path = "edit.action.history" +name = "redo" +key = "shift+u" +command = "runCommands" +args.commands = [ "redo", "selection-utilities.shrinkToActive" ] + +[[bind]] +path = "edit.action.basic" +name = 'toggle check' +description = "Toggle a markdown checkbox" +key = "shift+6" +command = "markdown-checkbox.markCheckbox" + +[[bind]] +path = "edit.action.clipboard" +key = "d" +name = "delete" +description = """ +Without a count: delete selected text (and store to clipboard). With a +count, delete up to the next `count` lines and store to clipboard. +""" +when = "!editorHasSelection" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.clipboardCutAction", + { command = "master-key.setMode", args = { value = "normal" } }, +] + +[[bind]] +path = "edit.action.clipboard" +key = "d" +when = "editorHasSelection" +command = "runCommands" +args.commands = [ + "editor.action.clipboardCutAction", + { command = "master-key.setMode", args = { value = "normal" } }, +] + +[[bind]] +path = "edit.action.clipboard" +key = "shift+d" +mode = "normal" +name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "cursorMove", args = { to = "wrappedLineEnd", select = true} }, + "editor.action.clipboardCutAction" +] + +[[bind]] +path = "edit.action.clipboard" +key = "shift+d" +mode = "normal" +when = "master-key.count > 1" +command = "runCommands" +args.commands = [{ defined = "selectLinesUp" }, "deleteRight"] + +[[bind]] +path = "edit.action.clipboard" +key = "y" +name = "copy" +description = "copy selected text to clipboard" +command = "runCommands" +args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] + +[[bind]] +path = "edit.action.clipboard" +key = "y" +when = "master-key.count > 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.clipboardCopyAction", + "selection-utilities.shrinkToActive" +] + +[[bind]] +path = "edit.action.clipboard" +key = "shift+y" +name = "copy (eol/up)" +description = "without a count: copy to end of line; with a count: copy this and the previous N lines" +when = "master-key.count <= 1" +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "cursorMove", args = { to = "wrappedLineEnd", select = true} }, + "editor.action.clipboardCopyAction", + "selection-utilities.shrinkToActive" +] + +[[bind]] +path = "edit.action.clipboard" +key = "shift+y" +when = "master-key.count > 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesUp" }, + "editor.action.clipboardCopyAction", + "selection-utilities.shrinkToActive" +] + +[[path]] +id = "edit.action.open_lines" +name = "Line opening actions" +description = """ +These commands provides several ways of adding lines above or below the current line +""" + +[[path]] +id = "edit.action.indent" +name = "Indentation" +description = """ +Operations that affect line indentation +""" + +[[bind]] +path = "edit.action.indent" +key = "shift+." +name = "indent" +description = "Indent lines" +command = "editor.action.indentLines" + +[[bind]] +path = "edit.action.indent" +key = "shift+." +name = "indent" +description = "Indent lines" +when = "master-key.count >= 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.indentLines" +] + +[[bind]] +path = "edit.action.indent" +key = "shift+," +name = "deindent" +when = "master-key.count < 1" +description = "De-indent lines" +command = "editor.action.outdentLines" + +[[bind]] +path = "edit.action.indent" +key = "shift+," +name = "deindent" +when = "master-key.count >= 1" +description = "Deindent lines" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.outdentLines", + "selection-utilities.shrinkToActive" +] + +[[path]] +id = "edit.action.history" +name = "History Commands" +description = "Commands that interact with edit or cursor history." + +# ## Number actions + +# These commands modify or enter numbers in some way. + +[[path]] +id = "edit.action.numbers" +name = "Number Editing" +description = "Commands that modify one or more numbers" + +[[bind]] +path = "edit.action.numbers" +name = 'inc #' +description = "Increment a number by 1" +key = "=" +command = "selection-utilities.incrementNumber" + +[[bind]] +path = "edit.action.numbers" +name = 'dec #' +description = "Decrement a number by 1 " +key = "shift+=" +command = "selection-utilities.decrementNumber" + +# ## Captilization + +# These modify the capitalization of letters in some way. + +[[path]] +id = "edit.action.capitals" +name = "Capitlization Actions" +description = "Actions that change how words are capitalized" +default.mode = ["normal", "selectedit"] + +[[bind]] +path = "edit.action.capitals" +name = 'camel' +description = "Swap style to lower camel case (`camelCase`)" +key = "` c" +command = "extension.changeCase.camel" + +[[bind]] +path = "edit.action.capitals" +name = 'constant' +description = "Swap style to constant (`IS_CONSTANT`)" +key = "` shift+u" +command = "extension.changeCase.constant" + +[[bind]] +path = "edit.action.capitals" +name = 'dot' +description = "Swap style to dot case (`dot.case`)" +key = "` ." +command = "extension.changeCase.dot" + +[[bind]] +path = "edit.action.capitals" +name = 'kebab' +description = "Swap style to kebab case (`kebab-case`)" +key = "` -" +command = "extension.changeCase.kebab" + +[[bind]] +path = "edit.action.capitals" +name = 'all lower' +description = "Swap all to lower case" +key = "` shift+l" +command = "extension.changeCase.lower" + +[[bind]] +path = "edit.action.capitals" +name = 'first lower' +description = "Swap first letter to lower case" +key = "` l" +command = "extension.changeCase.lowerFirst" + +[[bind]] +path = "edit.action.capitals" +name = 'spaces' +description = "Swap to spaces (`camelCase` -> `camel case`)" +key = "` space" +command = "extension.changeCase.no" + +[[bind]] +path = "edit.action.capitals" +name = 'Camel' +description = "Swap to upper camel case (`CamelCase`)" +key = "` shift+c" +command = "extension.changeCase.pascal" + +[[bind]] +path = "edit.action.capitals" +name = 'path' +description = "Swap to 'path' case (`path/case`)" +key = "` /" +command = "extension.changeCase.path" + +[[bind]] +path = "edit.action.capitals" +name = 'snake' +description = "Swap to snake case (`snake_case`)" +key = "` shift+-" +command = "extension.changeCase.snake" + +[[bind]] +path = "edit.action.capitals" +name = 'swap' +description = "Swap upper and lower case letters" +key = "` s" +command = "extension.changeCase.swap" + +[[bind]] +path = "edit.action.capitals" +name = 'title' +description = "Swap to title case (all words have first upper case letter)" +key = "` t" +command = "extension.changeCase.title" + +[[bind]] +path = "edit.action.capitals" +name = 'all upper' +description = "Swap to use all upper case letters" +key = "` shift+y" +command = "extension.changeCase.upper" + +[[bind]] +path = "edit.action.capitals" +name = 'first upper' +description = "Swap first character to upper case" +key = "` u" +command = "extension.changeCase.upperFirst" + +# ## "Do" Actions + +# These keys are all organized under the `space` key and they "do" something. These are generally more elaborate editing operations in the current editor pane. + +[[path]] +id = "edit.action.do" +name = "'Do' actions" +description = "Additional actions organized under the `'` (or 'do') prefix." +default.mode = "normal" + +[[bind]] +path = "edit.action.do" +name = "do" +key = "space" +description = "additional actions, mostly for modifying specific syntactic formats" +command = "master-key.prefix" + +[[bind]] +path = "edit.action.do" +name = "paste after line" +combinedName = "paste after/before line" +combinedKey = "p/shift+p" +description = "Paste text after current line" +priority = 2 +key = "space p" +command = "runCommands" +args.commands = [ + "expandLineSelection", + "selection-utilities.activeAtEnd", + "selection-utilities.shrinkToActive", + "editor.action.clipboardPasteAction", +] + +[[bind]] +path = "edit.action.do" +priority = 2 +name = "paste before line" +combinedName = "paste after/before line" +description = "Paste text before current line" +key = "space shift+p" +command = "runCommands" +args.commands = [ + "expandLineSelection", + "selection-utilities.activeAtStart", + "selection-utilities.shrinkToActive", + "editor.action.clipboardPasteAction", +] + +[[bind]] +path = "edit.action.do" +priority = 2 +name = "add line below" +combinedName = "add line below/above" +combinedDescription = "open a line below/above current line" +combinedKey = "o/shift+o" +description = "open a line below current line" +key = "space o" +command = "editor.action.insertLineAfter" + +[[bind]] +path = "edit.action.do" +name = "add line above" +priority = 2 +combinedName = "add line below/above" +description = "open a line above current line" +key = "space shift+o" +command = "editor.action.insertLineBefore" + +[[bind]] +path = "edit.action.do" +name = 'sym insert' +description = "Insert a character pair around a character" +priority = 1 +key = "space i" +combinedName = "sym insert (mode)" +combinedDescription = "Insert characters around pair (switching to syminster mode until hitting again)" +combinedKey = "i/shift+i" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.captureKeys" +args.acceptAfter = 1 + +[[bind.args.commands]] +command = "selection-utilities.insertAround" +computedArgs.before = "braces[captured].before || captured" +computedArgs.after = "braces[captured].after || captured" +args.followCursor = true + +[[bind]] +path = "edit.action.do" +name = 'trim white' +description = "Delete all external whitespace (left and right edges)" +key = "space shift+-" +command = "selection-utilities.trimWhitespace" + +[[bind]] +path = "edit.action.do" +key = "space w" +name = "wrap p" +combinedName = "wrap/join lines" +description = "wrap paragraph text, preserving commenting" +combinedDescription = "wrap paragraph text, preserving commenting / join lines together" +combinedKey = "w/j" +command = "rewrap.rewrapComment" + +[[bind]] +path = "edit.action.basic" +name = 'join' +combinedName = "wrap/join lines" +description = "Remove newline between current and next line" +key = "space j" +mode = ["normal", "selectedit"] +when = "!editorHasSelection" +command = "runCommands" +args.commands = [ { defined = "selectLinesDown" }, 'editor.action.joinLines' ] + +[[bind]] +path = "edit.action.basic" +combinedName = "wrap/join lines" +name = 'join' +description = "Remove newline between current and next line" +mode = ["normal", "selectedit"] +key = "space j" +command = "editor.action.joinLines" + +[[bind]] +path = "edit.action.do" +key = "space f" +name = "format" +combinedName = "format / format document" +when = "master-key.count < 1" +command = "editor.action.formatSelection" + +[[bind]] +path = "edit.action.do" +key = "space f" +combinedName = "format / format document" +combinedKey = "f/shift+f" +combinedDescription = "Format selection / document" +name = "format" +description = "Format sel" +when = "master-key.count >= 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.formatSelection", + "selection-utilities.shrinkToActive" +] + +[[bind]] +path = "edit.action.do" +key = "space shift+f" +name = "format doc" +combinedName = "format / format document" +command = "editor.action.formatDocument" + +[[path]] +id = "edit.action.brackets" +name = 'Bracket/Quote Editing' +description = "Commands that edit two matching brackets or quotes." + +[[bind]] +path = "edit.action.do" +name = 'parens' +description = "actions related to various brackets (`[`, `(`, `{`)" +key = "space [" +command = "master-key.prefix" + +[[bind]] +path = "edit.action.do" +name = 'remove' +description = "Removes surrounding pairs" +key = "space [ d" +command = "bracketeer.removeBrackets" + +[[bind]] +path = "edit.action.do" +name = 'parens/brackets' +description = "Swap between `[`, `(` and `{`" +key = "space [ s" +command = "bracketeer.swapBrackets" + +[[bind]] +path = "edit.action.do" +name = 'quotes' +description = "Actions related to quotes" +key = "space '" +command = "master-key.prefix" + +[[bind]] +path = "edit.action.do" +name = 'remove' +description = "Removes quotes (', \" or `)" +key = "space ' d" +command = "bracketeer.removeQuotes" + +[[bind]] +path = "edit.action.do" +name = 'swap' +description = "Swap quotes (', \" or `)" +key = "space ' s" +command = "bracketeer.swapQuotes" + +[[path]] +id = "edit.action.comment" +name = "Comments" +description = """ +Operations that modify comments +""" + +[[bind]] +path = "edit.action.do" +key = "space /" +combinedName = "(block) comment" +when = "master-key.count < 1" +command = "editor.action.commentLine" + +[[bind]] +path = "edit.action.do" +key = "space /" +name = "comment lines" +combinedName = "(block) comment" +combinedDescription = "Toggle (block) comment" +combinedKey = "(shift+)/" +description = "select next comment" +when = "master-key.count >= 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.commentLine", +] + +[[bind]] +path = "edit.action.do" +key = "space shift+/" +when = "master-key.count < 1" +combinedName = "(block) comment" +command = "editor.action.blockComment" + +[[bind]] +path = "edit.action.do" +key = "space shift+/" +name = "block comment lines" +combinedName = "(block) comment" +description = "select previous comment" +when = "master-key.count >= 1" +command = "runCommands" +args.commands = [ + { defined = "selectLinesDown" }, + "editor.action.blockComment", + "selection-utilities.shrinkToActive", +] + +[[bind]] +path = "edit.action.do" +name = 'inc all #' +combinedName = "inc/dec all #" +combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" +combinedKey = "=/shift+=" +description = "Increment selected numbers; increment increases per selection" +key = "space =" +command = "selection-utilities.incrementNumberPerSelection" + +[[bind]] +path = "edit.action.do" +name = 'dec all #' +combinedName = "inc/dec all #" +description = "Decrement selected numbers; decrement increases per selection" +key = "space shift+=" +command = "selection-utilities.decrementNumberPerSelection" + +[[bind]] +path = "edit.action.do" +name = 'nb cell' +description = "Actions related to notebook cells" +key = "space c" +command = "master-key.prefix" + +[[bind]] +path = "edit.action.do" +key = "space c i" +when = "editorLangId == 'quarto'" +command = "quarto.insertCodeCell" +name = "insert cell" +description = "insert a new cell in a notebook" + +[[bind]] +path = "edit.action.do" +key = "space c s" +when = "editorLangId != 'quarto'" +command = "jupyter.selectCell" + +[[bind]] +path = "edit.action.basic" +key = "space ." +name = 'sent. lines' +description = "Split paragraph into one line per sentence" +mode = "normal" +command = "runCommands" + +[[bind.args.commands]] +command = "selection-utilities.moveBy" +args.unit = "paragraph" +args.boundary = "both" +args.selectWhole = true + +[[bind.args.commands]] +command = "editor.action.joinLines" + +[[bind.args.commands]] +command = "selection-utilities.createBy" +args.text = "." + +[[bind.args.commands]] +command = "selection-utilities.shrinkToActive" + +[[bind.args.commands]] +command = "cursorRight" + +[[bind.args.commands]] +command = "type" +args.text = "\n" + +[[bind.args.commands]] +command = "selection-utilities.cancelSelection" + +# ## Repeat actions + +# These commands interact with the history of previously typed commands to repeat some sequence of commands. They can record any edits, and any commands that are issued through master key bindings. Commands that are not part of this binding file (e.g. a standard call to Cmd/Ctrl+V to paste) will not be recorded. You can copy your non-master-key bindings over to master key (so that they will be recorded) by [customizing your bindings](#customized-bindings) and using `Import Default Bindings` and `Import User Bindings` to allow all of the default and user bindings stored in VSCOde's normal keybinding files to be recorded by master key. (You will have to remove your original user bindings from the VSCOde `keybinding.json` file manually) + +[[bind]] +path = "edit.action.history" +name = "record" +description = "Start/stop recording Master Key commands" +key = "shift+q" +when = "!master-key.record" +command = "master-key.record" +args.on = true + +[[bind]] +path = "edit.action.history" +name = "record" +description = """ +Start/stop recording key presses defined by Master Key pushing it to the +top of the `history` stack once recording finishes." +""" +key = "shift+q" +when = "master-key.record" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.record" +args.on = false + +[[bind.args.commands]] +command = "master-key.pushHistoryToStack" +args.range.from = 'commandHistory[i-1].name === "record"' +args.range.to = "i" + +[[bind]] +path = "edit.action.history" +name = "replay" +description = """ +Replay the Master Key command sequence at the top of the `history` stack. Specifying +a count requests the Nth most recent item on this stack. +""" +key = "q q" +command = "master-key.replayFromStack" +computedArgs.index = "count" + +[[bind]] +path = "edit.action.history" +name = "store macro" +description = """ +Stores the top of the `history` stack into a named register. Specifying a count stores the +Nth most recent item on this stack. +""" +key = "q s" +command = "master-key.storeNamed" +args.description = "Save Macro" +args.name = "macro" +args.contents = "macro[macro.length-(count || 0)-1]" + +[[bind]] +path = "edit.action.history" +name = "replay stored" +description = """ +Replay a recorded Master Key command sequence from a named register, pushing +it to the front of the history stack. +""" +key = "q r" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.restoreNamed" +args.description = "Macro" +args.name = "macro" + +[[bind.args.commands]] +command = "master-key.pushHistoryToStack" +computedArgs.value = "captured" + +[[bind.args.commands]] +command = "master-key.replayFromStack" +args.index = 0 + +[[bind]] +path = "edit.action.history" +name = "store last" +description = """ +Store the N most recently run commands as a macro, where N is the count (defaulting to 1). +""" +key = "q l" +command = "master-key.pushHistoryToStack" +args.range.from = "i-(count || 0)" +args.range.to = "i" + +# ## Utility Commands + +# These actions include miscellaneous utilities. + +[[bind]] +path = "window" +key = "shift+ctrl+;" +name = "palette" +resetTransient = false +hideInPalette = true +mode = [] +prefixes = "" +description = """ +show command suggestions within the context of the current mode and keybinding prefix +(if any keys have already been typed) +""" +command = "master-key.commandPalette" + +[[bind]] +path = "util" +name = "git..." +description = "git commands" +key = "tab g" +command = "master-key.prefix" + +[[bind]] +path = "util" +name = "pull" +combinedName = "push/pull" +description = "pull changes from remote" +combinedDescription = "pull from/push to remote" +combinedKey = "p/shift+p" +key = "tab g p" +command = "git.pull" + +[[bind]] +path = "util" +name = "push" +description = "push changes to remote" +key = "tab g shift+p" +command = "git.push" + +[[bind]] +path = "util" +name = "checkout" +combinedName = "commit/checkout" +description = "commit changes" +combinedDescription = "commit/checkout git changes" +combinedKey = "c/shift+c" +key = "tab g c" +command = "git.commit" + +[[bind]] +path = "util" +name = "checkout" +combinedName = "commit/checkout" +description = "checkout changes" +key = "tab g shift+c" +command = "git.checkout" + +[[bind]] +path = "util" +name = "revert range" +description = "revert unstaged changes in selected range" +key = "tab g r" +command = "git.revertSelectedRanges" + +[[bind]] +path = "util" +name = "revert range" +description = "revert unstaged changes in selected range" +key = "tab g s" +command = "git.stageSelectedRanges" + +[[bind]] +path = "util" +name = "commands..." +description = "show GitLens command palette for git" +key = "tab g g" +command = "gitlens.gitCommands" + +# ## Miscellaneous Commands + +# These miscellaneous utility commands are all organized uner the prefix `tab`. + +[[path]] +id = "util" +name = "assorted misecellaneous commands" +default.kind = "util" +when = "editorTextFocus && !findWidgetVisible" + +[[bind]] +path = "util" +name = "utility" +key = "tab" +description = "utility related commands: file opening, window manipulation, debugging etc..." +command = "master-key.prefix" + +[[bind]] +path = "util" +name = "open recent" +description = "Open recent file" +key = "tab r" +command = "workbench.action.openRecent" + +[[bind]] +path = "util" +name = "hover" +description = "show the hover view" +combinedName = "(debug) hover" +combinedDescription = "show the (debug) hover view" +combinedKey = "(shift+)h" +key = "tab h" +command = "editor.action.showHover" + +[[bind]] +path = "util" +name = "debug hover" +combinedName = "(debug) hover" +description = "show the debug hover view" +key = "tab shift+h" +command = "editor.debug.action.showDebugHover" + +[[bind]] +path = "util" +name = "add mark" +combinedName = "add mark / mark..." +description = "toggle bookmark at given line" +combinedDescription = """ +toggle bookmark at given line / bookmark related commands +""" +key = "tab shift+m" +combinedKey = "shift+m / m" +command = "vsc-labeled-bookmarks.toggleBookmark" + +[[bind]] +path = "util" +name = "mark" +combinedName = "add mark / mark..." +description = "bookmark related commands" +key = "tab m" +command = "master-key.prefix" + +[[bind]] +path = "util" +name = "mark ↓" +description = "move to next bookmark" +combinedName = "mark ↓/↑" +combinedDescription = "move to next/previous bookmark" +combinedKey = "j/k" +key = "tab m j" +when = "!master-key.select_on && !editorHasSelection" +command = "vsc-labeled-bookmarks.navigateToNextBookmark" + +[[bind]] +path = "util" +combinedName = "mark ↓/↑" +key = "tab m j" +when = "master-key.select_on || editorHasSelection" +command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" + +[[bind]] +path = "util" +name = "mark ↑" +combinedName = "mark ↓/↑" +description = "move to previous bookmark" +key = "tab m k" +when = "!master-key.select_on && !editorHasSelection" +command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" + +[[bind]] +path = "util" +name = "mark ↑" +combinedName = "mark ↓/↑" +description = "move to previous bookmark" +key = "tab m k" +when = "master-key.select_on || editorHasSelection" +command = "runCommands" +args.commands = ["vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", + "selection-utilities.activeAtStart"] + +[[bind]] +path = "util" +name = "remove mark" +description = "remove bookmark (use quick selection)" +key = "tab m d" +command = "vsc-labeled-bookmarks.deleteBookmark" + +[[bind]] +path = "util" +name = "nav marks" +description = "reveal quick selection to move to a bookmark" +key = "tab m t" +command = "vsc-labeled-bookmarks.navigateToBookmark" + +[[bind]] +path = "util" +name = "error →" +combinedName = "error →/←" +combinedDescription = "move to next/previous error" +combinedKey = "e/shift+e" +description = """ +move to next error +""" +key = "tab e" +command = "editor.action.marker.next" + +[[bind]] +path = "edit.motion" +name = "error ←" +combinedName = "error →/←" +description = """ +move to previous error +""" +key = "tab shift+e" +command = "editor.action.marker.prev" + +[[bind]] +path = "edit.motion" +name = "diff →" +combinedName = "diff →/←" +combinedDescription = "move to and show next/previous diff" +combinedKey = "c/shift+c" +description = """ +move to and show next diff +""" +key = "tab c" +command = "editor.action.dirtydiff.next" + +[[bind]] +path = "edit.motion" +name = "diff ←" +combinedName = "diff →/←" +description = """ +move to and show previous diff +""" +key = "tab shift+c" +command = "editor.action.dirtydiff.previous" + +[[bind]] +path = "edit.motion" +name = "change →" +combinedName = "change →/←" +combinedDescription = "move to next/previous file change" +combinedKey = "d/shift+d" +description = """ +move to next file change +""" +key = "tab d" +command = "workbench.action.editor.nextChange" + +[[bind]] +path = "edit.motion" +name = "change ←" +combinedName = "change →/←" +description = """ +move to previous change +""" +key = "tab shift+d" +command = "workbench.action.editor.previousChange" + +# ## Window Manipulation + +# These are commands that interact with VSCode's user-interface in some way, rather than editing or moving around in the editor pane. + +[[path]] +id = "window" +name = "Window Manipulation" +description = "Commands for navigating and manipulating the window/editor panes in some way" +default.kind = "util" +default.mode = "normal" +when = "editorTextFocus && !findWidgetVisible" + +[[bind]] +path = "window" +name = "cntr win" +description = "center window at primary cursor position" +key = "tab l" +command = "selection-utilities.revealActive" +args.at = "center" +when = "editorTextFocus" + +[[bind]] +path = "window" +name = "window" +description = "window/editor pane manipulation-related commands" +key = "tab w" +command = "master-key.prefix" + +[[bind]] +path = "window" +name = "vert/horz" +key = "tab w r" +description = "Toggle between horizontal and vertical layouts" +command = "workbench.action.toggleEditorGroupLayout" + +[[bind]] +path = "window" +name = "next window" +combinedName = "next/previous window" +description = "move to next window" +combinedDescription = "move to next/prev window" +key = "tab ]" +combinedKey = "]/[" +command = "workbench.action.focusNextGroup" + +[[bind]] +path = "window" +name = "prev window" +combinedName = "next/previous window" +description = "move to previous window" +key = "tab [" +command = "workbench.action.focusPreviousGroup" + +[[bind]] +path = "window" +name = "move →" +combinedName = "move →/←" +combinedDescription = "move editor to window left/right" +combinedKey = "l/h" +description = "move editor to window to left" +key = "tab w l" +command = "workbench.action.moveEditorToRightGroup" + +[[bind]] +path = "window" +name = "←" +combinedName = "move →/←" +description = "move editor to window to left" +key = "tab w h" +command = "workbench.action.moveEditorToLeftGroup" + +[[bind]] +path = "window" +name = "↓" +combinedName = "move ↓/↑" +combinedDescription = "move editor to window above/below" +combinedKey = "j/k" +description = "move editor to window below" +key = "tab w j" +command = "workbench.action.moveEditorToBelowGroup" + +[[bind]] +path = "window" +name = "↑" +combinedName = "move ↓/↑" +description = "move editor to window above" +key = "tab w k" +command = "workbench.action.moveEditorToAboveGroup" + +[[bind]] +path = "window" +name = "split editor..." +description = "split editor to in a given direction" +key = "tab w s" +command = "master-key.prefix" + +[[bind]] +path = "window" +name = "move →" +combinedName = "split →/←" +combinedDescription = "move editor to window left/right" +combinedKey = "l/h" +description = "split editor to window to left" +key = "tab w s l" +command = "workbench.action.splitEditorRight" + +[[bind]] +path = "window" +name = "←" +combinedName = "split →/←" +description = "split editor to window to left" +key = "tab w s h" +command = "workbench.action.splitEditorLeft" + +[[bind]] +path = "window" +name = "↓" +combinedName = "split ↓/↑" +combinedDescription = "split editor to window above/below" +combinedKey = "j/k" +description = "split editor to window below" +key = "tab w s j" +command = "workbench.action.splitEditorDown" + +[[bind]] +path = "window" +name = "↑" +combinedName = "split ↓/↑" +combinedDescription = "split editor to window above/below" +combinedKey = "j/k" +description = "split editor to window below" +key = "tab w s k" +command = "workbench.action.splitEditorUp" + +[[bind]] +path = "window" +name = "close pane" +description = "close the given group of editors" +key = "tab w x" +command = "workbench.action.closeEditorsInGroup" + +[[bind]] +path = "window" +name = "max" +description = "minimize size of all other windows" +key = "tab w shift+m" +command = "workbench.action.minimizeOtherEditors" + +[[bind]] +path = "window" +name = "equal" +description = "equalize size of all windows" +key = "tab w =" +command = "workbench.action.evenEditorWidths" + +[[bind]] +path = "window" +name = "curs. win top" +description = "center window so that primary cursor is at the top" +key = "tab k" +combinedName = "center window top/bottom" +combinedDescription = "center window so that primary cursor is at the top/bottom" +combinedKey = "k/j" +command = "selection-utilities.revealActive" +args.at = "top" + +[[bind]] +path = "window" +name = "curs. win bot" +combinedName = "center window top/bottom" +description = "center window so that primary cursor is at the bottom" +key = "tab j" +command = "selection-utilities.revealActive" +args.at = "bottom" + +# ## Debugging Commands + +# Commands for interacting with VSCode's debugger UI. + +[[bind]] +path = "util" +name = "breakpt." +combinedName = "breakpt / debug..." +combinedKey = "shift+b/b" +description = "toggle debug breakpoint" +combinedDescription = "toggle debug breakpoint / debug related commands..." +key = "tab shift+b" +command = "editor.debug.action.toggleBreakpoint" + +[[bind]] +path = "util" +name = "debug..." +combinedName = "breakpt / debug..." +description = "assorted debugging actions" +key = "tab b" +command = "master-key.prefix" + +[[bind]] +path = "util" +name = "cond. break" +description = "conditional breakpoint" +key = "tab b shift+c" +command = "editor.debug.action.conditionalBreakpoint" + + +[[bind]] +path = "util" +name = "start" +description = "start debugging" +key = "tab b r" +command = "workbench.action.debug.start" + +[[bind]] +path = "util" +name = "continue" +description = "continue debugging" +key = "tab b c" +command = "workbench.action.debug.continue" + +[[bind]] +path = "util" +name = "next" +description = "debug: step over next line" +key = "tab b j" +command = "workbench.action.debug.stepOver" + +[[bind]] +path = "util" +name = "into" +description = "debug: step into next line" +key = "tab b i" +command = "workbench.action.debug.stepInto" + +[[bind]] +path = "util" +name = "out" +description = "debug: step out" +key = "tab b o" +command = "workbench.action.debug.stepOut" + +# ## Select-edit Mode + +# Select-edit mode allows you make a variety of kakoune-like modifications of one or more cursors. This lends itself to work flows such as: +# +# - select every line of text as a separate cursor, then filter out the lines you don't want +# - split an array by comma delimiters and edit each element of the array. +# - save a single selection to a list of selections to use for later and +# then move the cursor to the next selection you wish to add + +[[path]] +id = "edit.select_edit" +name = "Selection Editing" +description = "Various kakaune inspired commands for editing multiple selections" +default.mode = "selectedit" +default.kind = "motion" + +[[bind]] +path = "edit.select_edit" +name = "select-edit" +description = """ +Enter a mode where you can edit and manipulate (possibly multiple) selections. +""" +key = "'" +command = "master-key.setMode" +args.value = "selectedit" +mode = "normal" + +[[bind]] +path = "edit.select_edit" +key = "shift+'" +combinedName = "rm cursors" +combinedKey = "shift/ctrl+'" +combinedDescription = "Delete all selections and return to normal (multiple key variants)" +name = "del. cursors" +description = "Delete all selections and return to normal" +command = "runCommands" +args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] +mode = ["selectedit", "normal"] + +[[bind]] +path = "edit.select_edit" +key = "ctrl+'" +mode = ["insert", "selectedit", "normal"] +name = "rm cursors" +combinedName = "rm cursors" +description = "Delete all selections and return to normal" +command = "runCommands" +args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] + +[[bind]] +path = "edit.select_edit" +name = 'normal' +description = "return to normal mode" +key = "'" +command = "master-key.enterNormal" + +[[bind]] +path = "edit.select_edit" +name = "add →" +combinedName = "add →/←" +description = "add cursor at the next match to the primary cursor's text" +combinedDescription = "add cursor at the next/previous match to the primary cursor's text" +key = "l" +combinedKey = "l/h" +repeat = "count" +command = "selection-utilities.addNext" + +[[bind]] +path = "edit.select_edit" +name = "add ←" +combinedName = "add →/←" +description = "add cursor at the previous match to the primary cursor's text" +key = "h" +command = "selection-utilities.addPrev" +repeat = 'count' + +[[bind]] +path = "edit.select_edit" +name = "skip →" +combinedName = "skip →/←" +description = "move primary cursor to the next match of the primary cursor's text" +combinedDescription = "move primary cursor to the next/previous match of the primary cursor's text" +key = "shift+l" +combinedKey = "shift+l/h" +command = "selection-utilities.skipNext" +repeat = "count" + +[[bind]] +path = "edit.select_edit" +name = "skip ←" +combinedName = "skip →/←" +description = "move primary cursor to the previous match of the primary cursor's text" +key = "shift+h" +command = "selection-utilities.skipPrev" +repeat = 'count' + +[[bind]] +path = "edit.select_edit" +name = "align ←" +description = "align selections left" +key = "=" +command = "selection-utilities.alignSelectionsLeft" + +[[bind]] +path = "edit.select_edit" +name = "align →" +description = "align selections right" +key = "shift+=" +command = "selection-utilities.alignSelectionsRight" + +[[bind]] +path = "edit.select_edit" +name = "→ sel" +combinedName = "→/← sel" +description = """ +make the next selection primary; primary selections determine from where you add cursors, +what cursor you delete, and where the cursor goes when you clear or save selections +""" +combinedDescription = """ +make the next/previous selection primary; primary selections determine from where you add cursors, +what cursor you delete, and where the cursor goes when you clear or save selections +""" +key = "j" +combinedKey = "j/l" +command = "selection-utilities.movePrimaryRight" +repeat = 'count' + +[[bind]] +path = "edit.select_edit" +name = "← sel" +combinedName = "→/← sel" +description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" +key = "k" +command = "selection-utilities.movePrimaryLeft" +repeat = 'count' + +[[bind]] +path = "edit.select_edit" +name = "insert ↑" +combinedName = "insert ↑/↓" +description = """ +insert cursor on line above +""" +combinedDescription = "insert cursor on line above/below" +key = "shift+k" +combinedKey = "shift+k/j" +command = "editor.action.insertCursorAbove" +repeat = "count" + +[[bind]] +path = "edit.select_edit" +name = "insert sel ↓" +combinedName = "insert ↑/↓" +description = """ +insert cursor on line below +""" +key = "shift+j" +command = "editor.action.insertCursorBelow" +repeat = "count-1" + +[[bind]] +path = "edit.select_edit" +name = "del. primary" +combinedName = "del. primary/others" +description = "remove the primary selection" +combinedDescription = """ +Remove either the primary selection or all selections. Return to normal +mode if all selections are deleted. +""" +key = "d" +command = "selection-utilities.deletePrimary" +repeat = "count-1" + +[[bind]] +path = "edit.select_edit" +name = 'del. others' +description = "delete all other cursors but the primary selection" +key = "shift+d" +command = "removeSecondaryCursors" + +[[bind]] +path = "edit.select_edit" +name = "save sel" +description = """ +save all selections to the default register. +Use a count to specify an alternate register +""" +key = "c" +command = "runCommands" +args.commands = [ + { command = "selection-utilities.appendToMemory", computedArgs = { register = "count || 'default'" } }, + "selection-utilities.shrinkToActive", "master-key.enterNormal" +] + +[[bind]] +path = "edit.select_edit" +name = "load sel" +description = """ +load previously saved selections in the default register. +Use a count to specify an alternate register +""" +key = "v" +command = "runCommands" +args.commands = [ + { command = "selection-utilities.restoreAndClear", computedArgs = { register = "count || 'default'" } }, +] + +[[bind]] +path = "edit.select_edit" +name = "exchange sel" +description = """ +exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. +""" +key = "x" +command = "runCommands" +args.commands = [ + { command = "selection-utilities.swapWithMemory", computedArgs = {register = "count || 'default'"} }, + "master-key.enterNormal" +] + +[[bind]] +path = "edit.select_edit" +name = "rem saved sel" +description = """ +remove the most recently saved selection from the list of saved selections +""" +command = "runCommands" +key = "n" +args.commands = [ + { command = "selection-utilities.deleteLastSaved", computedArgs = {register = "count || 'default'"} }, + "master-key.enterNormal" +] + +[[bind]] +path = "edit.select_edit" +key = "shift+enter" +name = "split sel" +description = """ +split selection into multiple selections by new line charactesr +""" +command = "selection-utilities.splitByNewline" + +[[bind]] +path = "edit.select_edit" +name = "sel all" +description = """ +create a selection for every match of the current word (or selection) +""" +key = "shift+8" +command = "editor.action.selectHighlights" + +[[bind]] +path = "edit.select_edit" +name = "character" +description = "split by a given character" +key = "s" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.captureKeys" +args.acceptAfter = 1 + +[[bind.args.commands]] +command = "selection-utilities.splitBy" +computedArgs.text = "captured" + +[[bind]] +path = "edit.select_edit" +name = "string" +description = "split by a given string" +key = "shift+s" +command = "selection-utilities.splitBy" + +[[bind]] +path = "edit.select_edit" +name = "include" +description = """ +Include all selections that contain a given marker +""" +key = "f" +command = "selection-utilities.includeBy" + +[[bind]] +path = "edit.select_edit" +name = "exclude" +description = """ +Exclude all selections that contain a given marker +""" +key = "shift+f" +command = "selection-utilities.excludeBy" + +[[bind]] +path = "edit.select_edit" +name = "create" +description = "create selections of given string scoped to the current selections" +key = "/" +command = "selection-utilities.createBy" + +[[bind]] +path = "edit.select_edit" +name = "regex" +description = "operations by regex rather than string" +key = "r" +command = "master-key.prefix" + +[[bind]] +path = "edit.select_edit" +name = "split" +description = "split by a given regular expression" +key = "r shift+s" +command = "selection-utilities.splitByRegex" + +[[bind]] +path = "edit.select_edit" +name = "create" +description = "create selections of given regular expression scoped to the current selections" +key = "r /" +command = "selection-utilities.createByRegex" + +[[bind]] +path = "edit.select_edit" +name = "include" +description = "Include all selections that contain a given regular expression" +key = "r f" +command = "selection-utilities.includeByRegex" + +[[bind]] +path = "edit.select_edit" +name = "exclude" +description = "Exclude all selections that contain a given regular expression" +key = "r shift+f" +command = "selection-utilities.excludeByRegex" + +[[bind]] +path = "edit.select_edit" +key = "o" +name = "active to front" +combinedKey = "o/shift+o" +combinedName = "active to start/end" +combinedDescription = "move cursor to start/end of selection" +description = "move cursor to start of selection" +command = "selection-utilities.activeAtEnd" + +[[bind]] +path = "edit.select_edit" +name = "active to end" +combinedName = "active to start/end" +description = "move cursor to back of selection" +key = "shift+o" +command = "selection-utilities.activeAtStart" + +# ## Symmetric Insert Mode + +# Symmetric insert mode allows you to edit text at both the start and the beginning of a selection. When entering a character with a complimentary pair (e.g. `(` to `)`) entry is handled in the expected way. For example if you type `(` at the start of a selection while in symmetric insert mode, `)` will apepar at the end of the selection. + +# As a general rule, the letter keys issue commands of various sorts, and the other keys can be used to enter text (since we rarley want to surround a selection with an `a` but might want to surround it with `*` or `/`. + +[define.braces] + +"{".before = "{" +"{".after = "}" +"}".before = "{" +"}".after = "}" + +"[".before = "[" +"[".after = "]" +"]".before = "[" +"]".after = "]" + +"(".before = "(" +"(".after = ")" +")".before = "(" +")".after = ")" + +"<".before = "<" +"<".after = ">" +">".before = "<" +">".after = ">" + +[[mode]] +name = "syminsert" +highlight = "Highlight" +cursorShape = "BlockOutline" + +[[mode.onType]] +command = "selection-utilities.insertAround" +computedArgs.before = "braces[captured].before || captured" +computedArgs.after = "braces[captured].after || captured" +args.followCursor = true + +[[path]] +id = "edit.action.symmetric" +name = "Symmetric Operations" +description = "Operations that occur at both ends of a selection" +default.kind = "action" +default.mode = "syminsert" + +[[path]] +id = "edit.motion.symmetric" +name = "Symmetric Motions" +description = "Motions that occur at both ends of a selection" +default.kind = "motion" +default.mode = "syminsert" + +[[bind]] +path = "edit.action.symmetric" +name = "sym insert mode" +priority = 1 +description = """ +In this mode all commands and character insertions happen at both ends of +the selection +""" +mode = "normal" +key = "space shift+i" +combinedName = "sym insert (mode)" +command = "master-key.setMode" +args.value = "syminsert" + +[[bind]] +path = "edit.action.symmetric" +name = "Normal" +description = "Return to normal model" +key = "enter" +command = "master-key.setMode" +mode = "syminsert" + +[[bind]] +path = "edit.action.symmetric" +foreach.key = ["{key: [a-z]}", "shift+{key: [a-z]}"] +name = "" +description = "this key is ignored and has no associated command in syminsert mode" +key = "{key}" +command = "master-key.ignore" +mode = "syminsert" +hideInDocs = true +hideInPalette = true + +[[bind]] +name = "esc. char" +path = "edit.action.symmetric" +key = "\\" +description = "Insert escaped character" +command = "runCommands" + +[[bind.args.commands]] +command = "master-key.captureKeys" +args.acceptAfter = 1 + +[[bind.args.commands]] +command = "selection-utilities.insertAround" +computedArgs.before = "'\\\\' + (braces[captured].before || captured)" +computedArgs.after = "'\\\\' + (braces[captured].after || captured)" +args.followCursor = true + +[[bind]] +path = "edit.action.symmetric" +name = "delete" +key = "x" +description = """ +delete the first and last adjacent character when cursor is at end of selection and +delete the first and last character *in* the selection when cursor is at the start of the +selection +""" +command = "selection-utilities.deleteAround" +computedArgs.count = "count" +args.followCursor = true + +[[bind]] +path = "edit.motion.symmetric" +key = "l" +name = "sel →" +description = "shrink/grow selections in direction that's rightwards from cursor" +command = "selection-utilities.adjustSelections" +args.dir = "forward" +computedArgs.count = "count" + +[[bind]] +path = "edit.motion.symmetric" +key = "h" +name = "sel ←" +description = "shrink/grow selections in direction that's leftwards from cursor" +command = "selection-utilities.adjustSelections" +args.dir = "backward" +computedArgs.count = "count" + +[[bind]] +path = "edit.motion.symmetric" +key = "o" +name = "active to front" +combinedKey = "o/shift+o" +combinedName = "active to start/end" +combinedDescription = "move cursor to start/end of selection" +description = "move cursor to start of selection" +command = "selection-utilities.activeAtEnd" + +[[bind]] +path = "edit.motion.symmetric" +name = "active to end" +combinedName = "active to start/end" +description = "move cursor to back of selection" +key = "shift+o" +command = "selection-utilities.activeAtStart" + +[[bind]] +path = "edit.action.symmetric" +name = "undo" +key = "u" +command = "undo" + +[[bind]] +path = "edit.action.symmetric" +name = "redo" +key = "shift+u" +command = "redo" + +[[bind]] +path = "edit.motion.symmetric" +key = "v" +name = "shrink selection" +description = """ +reduce all selections to length zero and return to normal mode +""" +command = "runCommands" +args.commands = [ + "selection-utilities.shrinkToActive", + { command = "master-key.setFlag", args = { name = "select_on", value = false } }, + "master-key.enterNormal" +] diff --git a/old_format/parsing.ts b/old_format/parsing.ts new file mode 100644 index 00000000..3f08ed5c --- /dev/null +++ b/old_format/parsing.ts @@ -0,0 +1,459 @@ +import * as vscode from 'vscode'; +const TOML = require('smol-toml'); +import * as semver from 'semver'; +import z, {ZodIssue} from 'zod'; +import {ZodError, fromZodError, fromZodIssue} from 'zod-validation-error'; +import {expressionId} from '../expressions'; +import {uniqBy} from 'lodash'; +import replaceAll from 'string.prototype.replaceall'; +import {IParsedBindingDoc, parseBindingDocs} from './docParsing'; +export const INPUT_CAPTURE_COMMANDS = [ + 'captureKeys', + 'replaceChar', + 'insertChar', + 'search', +]; + +const bindingHeader = z + .object({ + version: z + .string() + .refine(x => semver.coerce(x), { + message: 'header.version is not a valid version number', + }) + .refine(x => semver.satisfies(semver.coerce(x)!, '1'), { + message: + 'header.version is not a supported version number (must a compatible with 1.0)', + }), + requiredExtensions: z.string().array().optional(), + name: z.string().optional(), + description: z.string().optional(), + }) + .strict(); +// type BindingHeader = z.infer; + +const rawBindingCommand = z + .object({ + command: z.string().optional(), // only optional before default expansion + args: z.any(), + computedArgs: z.object({}).passthrough().optional(), + if: z.string().or(z.boolean()).default(true).optional(), + }) + .strict(); +export type RawBindingCommand = z.infer; + +const definedCommand = z.object({defined: z.string()}).strict(); +export type DefinedCommand = z.infer; + +const ALLOWED_MODIFIERS = /Ctrl|Shift|Alt|Cmd|Win|Meta/i; +const ALLOWED_KEYS = [ + /f[1-9]/i, + /f1[0-9]/i, + /[a-z]/, + /[0-9]/, + /`/, + /-/, + /=/, + /\[/, + /\]/, + /\\/, + /;/, + /'/, + /,/, + /\./, + /\//, + /left/i, + /up/i, + /right/i, + /down/i, + /pageup/i, + /pagedown/i, + /end/i, + /home/i, + /tab/i, + /enter/i, + /escape/i, + /space/i, + /backspace/i, + /delete/i, + /pausebreak/i, + /capslock/i, + /insert/i, + /numpad[0-9]/i, + /numpad_multiply/i, + /numpad_add/i, + /numpad_separator/i, + /numpad_subtract/i, + /numpad_decimal/i, + /numpad_divide/i, + // layout independent versions + /\[f[1-9]\]/i, + /\[f1[0-9]\]/i, + /\[Key[A-Z]\]/i, + /\[Digit[0-9]\]/i, + /\[Numpad[0-9]\]/i, + /\[Backquote\]/, + /\[Minus\]/, + /\[Equal\]/, + /\[BracketLeft\]/, + /\[BracketRight\]/, + /\[Backslash\]/, + /\[Semicolon\]/, + /\[Quote\]/, + /\[Comma\]/, + /\[Period\]/, + /\[Slash\]/, + /\[ArrowLeft\]/, + /\[ArrowUp\]/, + /\[ArrowRight\]/, + /\[ArrowDown\]/, + /\[PageUp\]/, + /\[PageDown\]/, + /\[End\]/, + /\[Home\]/, + /\[Tab\]/, + /\[Enter\]/, + /\[Escape\]/, + /\[Space\]/, + /\[Backspace\]/, + /\[Delete\]/, + /\[Pause\]/, + /\[CapsLock\]/, + /\[Insert\]/, + /\[NumpadMultiply\]/, + /\[NumpadAdd\]/, + /\[NumpadComma\]/, + /\[NumpadSubtract\]/, + /\[NumpadDecimal\]/, + /\[NumpadDivide\]/, +]; + +function fullMatch(x: string, ex: RegExp) { + const m = x.match(ex); + if (m === null) { + return false; + } + return m[0].length === x.length; +} + +function isAllowedKeybinding(key: string) { + for (const press of key.split(/\s+/)) { + const modsAndPress = press.split('+'); + for (const mod of modsAndPress.slice(0, -1)) { + if (!ALLOWED_MODIFIERS.test(mod)) { + return false; + } + } + const unmodPress = modsAndPress[modsAndPress.length - 1]; + if (ALLOWED_KEYS.every(a => !fullMatch(unmodPress, a))) { + return false; + } + } + return true; +} + +export async function showParseError(prefix: string, error: ZodError | ZodIssue) { + let suffix = ''; + if ((error).code === undefined) { + // code is always defined on issues and undefined on errors + suffix = fromZodError(error).message; + } else { + suffix = fromZodIssue(error).message; + } + const buttonPattern = /\s+\{button:\s*"(.+)(? x.toLowerCase()); + +// function prefixError(arg: string) { +// return { +// message: `Expected either an array of kebydinings or the string '', +// but got '${arg}' instead`, +// }; +// } + +const parsedWhen = z.object({ + str: z.string(), + id: z.string(), +}); +export type ParsedWhen = z.infer; + +export function parseWhen(when_: string | string[] | undefined): ParsedWhen[] { + const when = when_ === undefined ? [] : !Array.isArray(when_) ? [when_] : when_; + return when.map(w => { + w = replaceAll( + w, + /editorTextFocus/g, + '(editorTextFocus || master-key.keybindingPaletteOpen && master-key.keybindingPaletteBindingMode)' + ); + // let p = jsep(w); + return {str: w, id: expressionId(w)}; + }); +} + +export const vscodeBinding = z.object({ + key: bindingKey, + command: z.string(), + args: z.object({}).optional(), + when: z.string().optional(), +}); + +export const rawBindingItem = z + .object({ + name: z.string().optional(), + description: z.string().optional(), + hideInPalette: z.boolean().default(false).optional(), + hideInDocs: z.boolean().default(false).optional(), + combinedName: z.string().optional().default(''), + combinedKey: z.string().optional().default(''), + combinedDescription: z.string().optional().default(''), + path: z.string().optional(), + priority: z.number().default(0).optional(), + kind: z.string().optional(), + key: z.string().optional(), + foreach: z.record(z.string(), z.array(z.string())).optional(), + when: z + .union([z.string(), z.string().array()]) + .optional() + .transform(parseWhen) + .pipe(parsedWhen.array()), + mode: z.union([z.string(), z.string().array()]).optional(), + prefixes: z + .preprocess( + x => (x === '' ? [] : x), + bindingKey.or(z.string().length(0)).array() + ) + .optional(), + resetTransient: z.boolean().optional(), + repeat: z.number().min(0).or(z.string()).default(0).optional(), + }) + .merge(rawBindingCommand) + .strict(); +export type RawBindingItem = z.output; + +// a strictBindingItem is satisfied after expanding all default fields +export const bindingCommand = rawBindingCommand.required({command: true}); +export type BindingCommand = z.infer; + +export const doArgs = bindingCommand.array().refine( + xs => { + let acceptsInput = 0; + for (const x of xs) { + if (INPUT_CAPTURE_COMMANDS.some(i => i === x.command)) { + acceptsInput = +1; + } + } + return acceptsInput <= 1; + }, + { + message: + '`runCommand` arguments can include only one command that accepts user input.', + } +); +export type DoArgs = z.infer; + +// TODO: the errors are not very informative if we transform the result so early in this +// way; we need to keep this as close as possible to the form in the raw file +export const bindingItem = z + .object({ + key: bindingKey, + when: parsedWhen.array(), + command: z.literal('master-key.do'), + mode: z + .string() + .or(z.object({implicit: z.string()})) + .array() + .optional(), + prefixes: z.string().array().optional().default(['']), + args: z + .object({ + do: doArgs, + path: z.string().optional().default(''), + hideInPalette: z.boolean().default(false).optional(), + hideInDocs: z.boolean().default(false).optional(), + priority: z.number().optional().default(0), + combinedName: z.string().optional().default(''), + combinedKey: z.string().optional().default(''), + combinedDescription: z.string().optional().default(''), + resetTransient: rawBindingItem.shape.resetTransient, + kind: z.string().optional().default(''), + repeat: z.number().min(0).or(z.string()).default(0), + }) + .merge(rawBindingItem.pick({name: true, description: true})), + }) + .required({key: true, when: true, args: true}) + .strict(); +export type BindingItem = z.output; + +export const bindingPath = z.object({ + // TODO: change from an empty `id` path, to fields at the top level in the header + id: z.string().regex(/(^$|[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*)/), + name: z.string(), + description: z.string().optional(), + default: rawBindingItem.partial().optional(), + when: z.string().optional().transform(parseWhen).pipe(parsedWhen.array().optional()), +}); + +const modeSpec = z.object({ + name: z.string(), + default: z.boolean().optional().default(false), + highlight: z.enum(['NoHighlight', 'Highlight', 'Alert']).default('NoHighlight'), + recordEdits: z.boolean().optional().default(false), + cursorShape: z + .enum(['Line', 'Block', 'Underline', 'LineThin', 'BlockOutline', 'UnderlineThin']) + .default('Line'), + onType: doArgs.optional(), + fallbackBindings: z.string().optional().default(''), +}); +export type ModeSpec = z.output; + +const kindItem = z + .object({ + name: z.string(), + description: z.string(), + }) + .strict(); +export type KindItem = z.output; + +export const bindingSpec = z + .object({ + header: bindingHeader, + bind: rawBindingItem.array(), + kind: kindItem.array().optional(), + path: bindingPath + .array() + .refine(xs => uniqBy(xs, x => x.id).length === xs.length, { + message: "Defined [[path]] entries must all have unique 'id' fields.", + }) + .optional() + .default([]), + mode: modeSpec + .array() + .optional() + .default([ + { + name: 'default', + default: true, + recordEdits: true, + cursorShape: 'Line', + highlight: 'NoHighlight', + }, + ]) + .refine( + xs => { + return uniqBy(xs, x => x.name).length === xs.length; + }, + {message: 'All mode names must be unique!'} + ) + .refine( + xs => { + const defaults = xs.filter(x => x.default); + return defaults.length === 1; + }, + {message: 'There must be one and only one default mode'} + ) + .transform(xs => { + const captureMode = xs.filter(x => x.name === 'capture'); + if (captureMode.length === 0) { + return xs.concat({ + name: 'capture', + cursorShape: 'Underline', + default: false, + recordEdits: false, + highlight: 'Highlight', + fallbackBindings: '', + }); + } + return xs; + }), + define: z.record(z.string(), z.any()).optional().default({}), + }) + .strict(); +export type BindingSpec = z.infer; + +export type FullBindingSpec = BindingSpec & { + doc?: IParsedBindingDoc[]; +}; + +export interface SuccessResult { + success: true; + data: T; +} +export interface ErrorResult { + success: false; + error: ZodError; +} +export type ParsedResult = SuccessResult | ErrorResult; + +export async function parseBindings(text: string): Promise> { + const data = bindingSpec.safeParse((await TOML).parse(text)); + if (data.success) { + const doc = parseBindingDocs(text); + + if (doc.success) { + return {success: true, data: {...data.data, doc: doc.data?.doc}}; + } else { + return >doc; + } + } else { + return >data; + } +} + +export async function parseBindingFile(file: vscode.Uri) { + const fileData = await vscode.workspace.fs.readFile(file); + const fileText = new TextDecoder().decode(fileData); + return parseBindings(fileText); +} + +export interface IConfigKeyBinding { + key: string; + command: 'master-key.do'; + prefixDescriptions: string[]; + when: string; + args: { + do: DoArgs; + key: string; // repeated here so that commands can display the key pressed + name?: string; + description?: string; + resetTransient?: boolean; + hideInPalette?: boolean; + hideInDocs?: boolean; + priority: number; + combinedName: string; + combinedKey: string; + combinedDescription: string; + kind: string; + path: string; + mode: string | undefined; + prefixCode: number | undefined; + }; +} diff --git a/src/extension/commands/namedStore.ts b/src/extension/commands/namedStore.ts index 774949c0..0cda5c5f 100644 --- a/src/extension/commands/namedStore.ts +++ b/src/extension/commands/namedStore.ts @@ -12,7 +12,7 @@ import { bindingCommand } from '../keybindings/parsing'; * @command storeNamed * @order 105 * - * Allow the user to specify a name where an [expression's](/bindings/bind#expression) + * Allow the user to specify a name where an [expression's](/expression/index) * result can be stored. Can be retrieved later using * [`restoreNamed`](/commands/restoreNamed). * @@ -22,7 +22,7 @@ import { bindingCommand } from '../keybindings/parsing'; * this allows calls to store and restore values to be specific to the relevant context * (e.g. only stored macros show up in commands related to macros, and only stored * bookmarks show up in commands related to bookmarks). - * - `content`: A string to be evaluated as an [expression](/expressions/index) + * - `content`: the value to store, usually passed as an [expression](/expression/index). */ const storeNamedArgs = z.object({ diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 309f0d9f..e8e868d8 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -141,7 +141,10 @@ pub struct BindingInput { /// an empty array, which indicates that no prior keys can have been pressed. Setting /// this to '{{all_prefixes()}}', will allow a key binding to work /// regardless of any unresolved key sequence that has been pressed: this is how `esc` - /// is defined to work in Larkin. + /// is defined to work in Larkin. (See also [`not_prefixes(...)`](/expressions/index)). + /// Note that if `prefixes` is an expression, it *cannot* produce a novel prefix + /// not defined elsewhere. This is to avoid circular computation when + /// resolving the return value of `all_prefixes`. #[serde(default = "span_plural_default")] pub prefixes: Spanned>>, @@ -634,6 +637,166 @@ impl Resolving> for Option { } } +// +// ================ Legacy `[[bind]]` warnings ================ +// + +// tracks fields that used to exist in [[bind]] in file format 1.0 +// so that we can generate warnings +#[allow(non_snake_case)] +#[derive(Deserialize, Clone, Debug)] +pub struct LegacyBindingInput { + computedArgs: Option>, + path: Option>, + mode: Option>>, // to check for `!` prefixed mode names etc... + prefixes: Option>>, // to check for ``. + name: Option>, + description: Option>, + hideInPalette: Option>, + hideInDocs: Option>, + combinedName: Option>, + combinedDescription: Option>, + combinedKey: Option>, + resetTransient: Option>, +} + +impl LegacyBindingInput { + pub(crate) fn check(&self) -> ResultVec<()> { + let mut errors = Vec::new(); + if let Some(spanned) = &self.computedArgs { + let err: Result<()> = Err(wrn!( + "`computedArgs` is no longer used in the 2.0 format; replace \ + `computedArgs.f = \"x+1\"` with `args.f = '{}'`", + "{{x+1}}" + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()); + } + + if let Some(spanned) = &self.path { + let err: Result<()> = Err(wrn!( + "`path` no longer exists in the 2.0 format; replace \ + `path` with `default` and review changes in documentation", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + + if let Some(spanned) = &self.mode { + let span = spanned.span().clone(); + if let Plural(modes) = spanned.as_ref().clone() { + if modes.iter().any(|s| s.starts_with("!")) { + let err: Result<()> = Err(wrn!( + "file format 2.0 does not support excluding modes using \ + `!mode_name`, use an expression like `{}` instead", + "{{not_modes([\"mode_name\"])}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) + } + + if modes.len() == 0 { + let err: Result<()> = Err(wrn!( + "2.0 no longer supports expression all modes using an empty array\ + use the expression `{}` instead", + "{{all_modes()}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) + } + } + } + + if let Some(spanned) = &self.prefixes { + let span = spanned.span().clone(); + if let Plural(prefixes) = spanned.as_ref().clone() { + if prefixes.iter().any(|s| s == "") { + let err: Result<()> = Err(wrn!( + "file format 2.0 does not support ``, use `{}` \ + instead", + "{{all_prefixes()}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) + } + } + } + + if let Some(spanned) = &self.name { + let err: Result<()> = Err(wrn!( + "`name` no longer exists in the 2.0 format; replace \ + `name` with `doc.name`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + if let Some(spanned) = &self.description { + let err: Result<()> = Err(wrn!( + "`description` no longer exists in the 2.0 format; replace \ + `description` with `doc.description`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + if let Some(spanned) = &self.hideInPalette { + let err: Result<()> = Err(wrn!( + "`hideInPalette` no longer exists in the 2.0 format; replace \ + `hideInPalette` with `doc.hideInPalette`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + if let Some(spanned) = &self.hideInDocs { + let err: Result<()> = Err(wrn!( + "`hideInDocs` no longer exists in the 2.0 format; replace \ + `hideInDocs` with `doc.hideInDocs`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + + if let Some(spanned) = &self.combinedName { + let err: Result<()> = Err(wrn!( + "`combinedName` no longer exists in the 2.0 format; replace \ + `combinedName` with `doc.combeind.name`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + if let Some(spanned) = &self.combinedDescription { + let err: Result<()> = Err(wrn!( + "`combinedDescription` no longer exists in the 2.0 format; replace \ + `combinedDescription` with `doc.combeind.description`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + if let Some(spanned) = &self.combinedKey { + let err: Result<()> = Err(wrn!( + "`combinedKey` no longer exists in the 2.0 format; replace \ + `combinedKey` with `doc.combeind.key`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + + if let Some(spanned) = &self.resetTransient { + let err: Result<()> = Err(wrn!( + "`resetTransient` no longer exists in the 2.0 format; replace \ + `resetTransient` with `finalKey`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } + + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(()); + } + } +} + // // ================ `[[bind]]` object ================ // diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 07f1c0b8..89532bdf 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -21,8 +21,8 @@ use crate::{ /// # Expressions /// /// You can use expressions in a number of places inside a [bind](/bindings/bind) -/// definition. An expression is a snippet of code surrounded by double curly braces {{like + this}} that occurs within a TOML string. +/// definition. An expression is a snippet of code surrounded by double curly braces +/// {{like + this}} that occurs within a TOML string. /// /// When the string is comprised entirely of a single expression, it can evaluate to any /// valid TOML object. @@ -79,6 +79,8 @@ use crate::{ /// string /// - `all_prefixes()`: returns an array of strings of all keybinding prefixes defined by /// the current set of keybindigs +/// - `not_prefixes([exclusions])`: given an array of strings of prefixes not to use, +/// returns all prefixes defined by the current set of keybindings. /// - `all_modes()`: returns an array of strings all keybinding modes defined by the current /// keybinding set /// - `not_modes([exclusions])`: given an array of strings of excluded modes, returns diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 028f4d73..e52da874 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -5,6 +5,7 @@ /// # Master Keybindings /// /// This defines version 2.0 of the master keybinding file format. +/// Breaking changes from version 1.0 are [described below](#breaking-changes) /// /// Master keybindings are [TOML](https://toml.io/en/) files composed of the following /// top-level fields: @@ -82,15 +83,54 @@ /// args.to = "right" /// args.value = "{{foo+1}}" /// ``` +/// ## Breaking Changes +/// +/// The following changes were made from version 1.0 of the file format. +/// +/// - `header.version` is now 2.0 +/// - [`[[define]]`](/bindings/define) now has several sub fields. Definitions +/// previously under `[[define]]` should now usually go under `[[define.val]]`, but +/// also see `[[define.command]]`. +/// - generalized [expressions](/expressions/index) which then changed or replaced several +/// other features: +/// - `bind.computedArgs` no longer exists: instead place expressions inside of `args` +/// - [`bind.foreach`](/bindings/bind#foreach-clause) have changed +/// - `{key: [regex]}` is now {{keys(`[regex]`)}} +/// - foreach variables are interpolated as expressions (`{{symbol}}` +/// instead of `{symbol}`). +/// - `bind.path` and `[[path]]`: A similar, but more explicit approach +/// is possible using `default` and [`define.bind`](/bindings/define#binding-definitions) +/// - replaced `mode = []` with `mode = '{{all_modes()}}'` +/// - replaced "<all-prefixes>" with `'{{all_prefixes()}}'` **TODO** +/// - replaced `mode = ["!insert", "!capture"]` with +/// `mode = '{{not_modes(["insert", "capture"])}}'` +/// - renamed several fields: +/// - `name`, `description`, `hideInPalette` and `hideInDocs` moved to +/// `doc.name`, `doc.description`, `doc.hideInPalette` and `doc.hideInDocs` +/// - `combinedName`, `combinedDescription` and `combinedKey` moved to +/// `doc.combined.name`, `doc.combined.description` and `doc.combined.key`. +/// - `resetTransient` is now [`finalKey`](/bindings/bind) +/// - `bind.if` is renamed to [`bind.skipWhen`](/bindings/bind) +/// - `name` renamed to `register` in [`(re)storeNamed`](/commands/storeNamed) command +/// - Rename replay-related command fields: +/// - `at` to `whereIndexIs` +/// - `range` to `whereRangeIs` +/// - the variable `i` renamed to `index` #[allow(unused_imports)] use log::{error, info}; -use crate::bind::{Binding, BindingCodes, BindingInput, BindingOutput, KeyId, UNKNOWN_RANGE}; +use crate::bind::{ + Binding, BindingCodes, BindingInput, BindingOutput, KeyId, LegacyBindingInput, UNKNOWN_RANGE, +}; use crate::define::{Define, DefineInput}; -use crate::error::{ErrorContext, ErrorReport, ResultVec, flatten_errors}; +use crate::error::{ErrorContext, ErrorReport, ErrorSet, Result, ResultVec, flatten_errors}; use crate::expression::Scope; +use crate::expression::value::{Expanding, Expression, Value}; use crate::mode::{ModeInput, Modes}; +use crate::wrn; +use lazy_static::lazy_static; +use regex::Regex; use serde::{Deserialize, Serialize}; use std::collections::{HashSet, VecDeque}; use toml::Spanned; @@ -240,7 +280,7 @@ pub struct KeyFileResult { #[wasm_bindgen] pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { return match parse_bytes_helper(&file_content) { - Ok(result) => KeyFileResult { + Ok((result, warnings)) => KeyFileResult { file: Some(result), errors: None, }, @@ -251,10 +291,89 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { }; } -fn parse_bytes_helper(file_content: &[u8]) -> ResultVec { +fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { let parsed = toml::from_slice::(file_content)?; let mut scope = Scope::new(); // TODO: do something with this scope?? - return KeyFile::new(parsed, &mut scope); + let bind = parsed.bind.clone(); + let result = KeyFile::new(parsed, &mut scope); + + let legacy_check = bind.map_expressions(&mut |ex @ Expression { .. }| { + if OLD_EXPRESSION.is_match(&ex.content) { + Err(wrn!( + "In format 2.0, expressions must now be surrounded in double curly\ + braces, not single.", + )) + .with_range(&ex.span.clone())?; + } + return Ok(Value::Exp(ex)); + }); + let mut warnings = match legacy_check { + Err(e) => e, + Ok(_) => vec![].into(), + }; + match result { + Ok(key_file) => Ok((key_file, warnings)), + Err(mut e) => Err({ + e.errors.append(&mut warnings.errors); + e + }), + } +} + +// +// ---------------- Legacy Keybinding warnings ---------------- +// + +#[derive(Deserialize, Clone, Debug)] +struct LegacyKeyFileInput { + bind: Vec>, + path: Option>>, +} + +lazy_static! { + static ref OLD_EXPRESSION: Regex = Regex::new(r"\{\w+\}").unwrap(); +} + +impl LegacyKeyFileInput { + fn check(&self) -> ErrorSet { + let mut errors = Vec::new(); + for bind in &self.bind { + match bind.as_ref().check() { + Ok(()) => (), + Err(mut e) => errors.append(&mut e.errors), + } + } + + let empty = vec![]; + for path in self.path.as_ref().unwrap_or(&empty) { + let err: Result<()> = Err(wrn!( + "`[[path]]` section is not supported in the 2.0 format; replace `path` \ + with `[[define.bind]]` and review more details in documentation" + )) + .with_range(&path.span()); + errors.push(err.unwrap_err()); + } + + return errors.into(); + } +} + +pub fn identify_legacy_warnings_helper(file_content: &[u8]) -> ResultVec<()> { + let warnings = toml::from_slice::(&file_content)?; + return Err(warnings.check()); +} + +pub fn identify_legacy_warnings(file_content: Box<[u8]>) -> KeyFileResult { + return match identify_legacy_warnings_helper(&file_content) { + Ok(()) => KeyFileResult { + file: None, + errors: None, + }, + Err(e) => KeyFileResult { + file: None, + errors: Some(e.errors.iter().map(|x| x.report(&file_content)).collect()), + }, + }; } #[cfg(test)] @@ -289,7 +408,7 @@ mod tests { command = "cursorLeft" "#; - let result = parse_bytes_helper(data.as_bytes()).unwrap(); + let (result, _) = parse_bytes_helper(data.as_bytes()).unwrap(); assert_eq!(result.bind[0].key[0], "l"); assert_eq!(result.bind[0].commands[0].command, "cursorRight"); @@ -932,6 +1051,35 @@ mod tests { assert_eq!(result.key_bind.len(), 8) } + #[test] + fn raises_legacy_warnings() { + let data = r#" + [[path]] + id = "modes" + description = "foo bar" + + [[bind]] + path = "modes" + name = "normal" + description = "All the legacy features!" + foreach.key = ["escape", "ctrl+[", "{key: [0-9]}"] + combinedKey = "a/b" + combinedName = "all" + combinedDescription = "all the things" + key = "{key}" + mode = [] + hideInPalette = true + hideInDocs = false + command = "master-key.enterNormal" + computedArgs = "a+1" + when = "!findWidgetVisible" + prefixes = "" + "#; + + let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); + assert_eq!(warnings.errors.len(), 12); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) From f42d407a2c06a610b8d395bc140d14152dcfdfc5 Mon Sep 17 00:00:00 2001 From: David Little Date: Tue, 7 Oct 2025 11:07:00 -0400 Subject: [PATCH 66/79] implemented `kind` Created using spr 1.3.6-beta.1 --- notes.md | 23 +++++---- src/rust/parsing/src/bind.rs | 78 ++++++++++++++++++------------ src/rust/parsing/src/expression.rs | 2 + src/rust/parsing/src/file.rs | 46 +++++++++++++++--- src/rust/parsing/src/kind.rs | 68 ++++++++++++++++++++++++++ src/rust/parsing/src/lib.rs | 1 + 6 files changed, 171 insertions(+), 47 deletions(-) create mode 100644 src/rust/parsing/src/kind.rs diff --git a/notes.md b/notes.md index bce961e1..89592a51 100644 --- a/notes.md +++ b/notes.md @@ -80,7 +80,7 @@ Integration test debugging: - [X] foreach expansion (unit tests remain) - [X] expand keys in `foreach` lists - [x] include `Spanned` in fields of `BindInput` - - [ ] pipeline for `[[bind]]` entries + - [X] pipeline for `[[bind]]` entries - [X] basic pipeline - [X] implement parsing of vscode file with rust command (and generate problems) - [X] we need to detect that the file should be parsed @@ -223,15 +223,16 @@ Integration test debugging: - [X] unit test - [X] `{{all_modes()}}` - [X] `{{not_modes(["not_me", "or_me"])}}` - - [ ] find low hanging fruit for problems with using 1.0 files / bad fields + - [X] find low hanging fruit for problems with using 1.0 files / bad fields - [X] implement tooling to use different levels (warn/info) in error reporting - - [~] fields that exist in the old but not new (use `#[serde(flatten)]`) - - [ ] review strings for single `{}` braces and warn that `{{}}` are now required - - [ ] others? - - [ ] implement `[[kind]]` (or redesign) + - [X] fields that exist in the old but not new (use `#[serde(flatten)]`) + - [X] review strings for single `{}` braces and warn that `{{}}` are now required + - [X] others? + - [X] implement `[[kind]]` (or redesign) + - [X] add legacy check for kind (since its also in the docs) - [ ] implement `[header]` section - - [ ] instead of using `.mk.toml`, look for a specific heading in the file + - [ ] instead of using `.mk.toml`, look for a specific heading comment in the file - [ ] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression which has nothing to do with the line and char position in the parent @@ -239,19 +240,21 @@ Integration test debugging: - [ ] error handling checks - [ ] make sure a range is always provided - [ ] test that all error messages show up when expected + - [ ] review coverage to verify there aren't additional checks we're missing - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) - [X] encode prefixes as prefixCode in when clause - [X] move mode to when clause - [X] generate all binding outputs in file object + - [X] unit tests for binding output generation - [ ] review existing binding resolution logic to make sure we didn't miss - something - - [ ] unit tests for binding output generation - - [ ] write `BindingOutput` to keybindings.json + something (particularly around prioritizing/ordering bindings) + - [ ] incorporate a write `BindingOutput` to keybindings.json into ts workflow - [ ] re-implement master-key.do and master-key.prefix - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make sense) + - [ ] figure out how to handle ts/rust statement management - [ ] move all bare variables in an expression to `key.` or `code.` object - [ ] use rust scope instead of TS state object (update state.ts) - [ ] properly handle command queues (now controlled by rust) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index e8e868d8..d413544a 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -652,6 +652,7 @@ pub struct LegacyBindingInput { prefixes: Option>>, // to check for ``. name: Option>, description: Option>, + kind: Option>, hideInPalette: Option>, hideInDocs: Option>, combinedName: Option>, @@ -684,41 +685,39 @@ impl LegacyBindingInput { if let Some(spanned) = &self.mode { let span = spanned.span().clone(); - if let Plural(modes) = spanned.as_ref().clone() { - if modes.iter().any(|s| s.starts_with("!")) { - let err: Result<()> = Err(wrn!( - "file format 2.0 does not support excluding modes using \ - `!mode_name`, use an expression like `{}` instead", - "{{not_modes([\"mode_name\"])}}" - )) - .with_range(&span); - errors.push(err.unwrap_err()) - } + let Plural(modes) = spanned.as_ref().clone(); + if modes.iter().any(|s| s.starts_with("!")) { + let err: Result<()> = Err(wrn!( + "file format 2.0 does not support excluding modes using \ + `!mode_name`, use an expression like `{}` instead", + "{{not_modes([\"mode_name\"])}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) + } - if modes.len() == 0 { - let err: Result<()> = Err(wrn!( - "2.0 no longer supports expression all modes using an empty array\ - use the expression `{}` instead", - "{{all_modes()}}" - )) - .with_range(&span); - errors.push(err.unwrap_err()) - } + if modes.len() == 0 { + let err: Result<()> = Err(wrn!( + "2.0 no longer supports expressions; all modes using an empty array\ + use the expression `{}` instead", + "{{all_modes()}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) } } if let Some(spanned) = &self.prefixes { let span = spanned.span().clone(); - if let Plural(prefixes) = spanned.as_ref().clone() { - if prefixes.iter().any(|s| s == "") { - let err: Result<()> = Err(wrn!( - "file format 2.0 does not support ``, use `{}` \ - instead", - "{{all_prefixes()}}" - )) - .with_range(&span); - errors.push(err.unwrap_err()) - } + let Plural(prefixes) = spanned.as_ref().clone(); + if prefixes.iter().any(|s| s == "") { + let err: Result<()> = Err(wrn!( + "file format 2.0 does not support ``, use `{}` \ + instead", + "{{all_prefixes()}}" + )) + .with_range(&span); + errors.push(err.unwrap_err()) } } @@ -738,6 +737,14 @@ impl LegacyBindingInput { .with_range(&spanned.span()); errors.push(err.unwrap_err()) } + if let Some(spanned) = &self.kind { + let err: Result<()> = Err(wrn!( + "`kind` no longer exists in the 2.0 format; replace \ + `kind` with `doc.kind`", + )) + .with_range(&spanned.span()); + errors.push(err.unwrap_err()) + } if let Some(spanned) = &self.hideInPalette { let err: Result<()> = Err(wrn!( "`hideInPalette` no longer exists in the 2.0 format; replace \ @@ -979,7 +986,7 @@ pub struct BindingDoc { pub hideInPalette: bool, pub hideInDocs: bool, pub combined: Option, - pub kind: String, + pub kind: Option, } #[derive(Clone, Debug, Serialize, Default)] @@ -994,13 +1001,22 @@ pub struct CombinedBindingDoc { #[wasm_bindgen] impl BindingDoc { pub(crate) fn new(input: BindingDocInput, scope: &mut Scope) -> ResultVec { + // kind validation + let kind_span = input.kind.as_ref().map(|x| x.span()); + let kind: Option = resolve!(input, kind, scope)?; + if let Some(k) = &kind { + if !scope.kinds.contains(k) { + return Err(err!("Undefined kind `{}`", k)).with_range(&kind_span.unwrap())?; + } + }; + return Ok(BindingDoc { name: resolve!(input, name, scope)?, description: resolve!(input, description, scope)?, hideInPalette: resolve!(input, hideInPalette, scope)?, hideInDocs: resolve!(input, hideInDocs, scope)?, combined: resolve!(input, combined, scope)?, - kind: resolve!(input, kind, scope)?, + kind, }); } } diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 89532bdf..865e3545 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -120,6 +120,7 @@ pub struct Scope { pub(crate) engine: rhai::Engine, pub(crate) prefixes: HashSet, pub(crate) modes: HashSet, + pub(crate) kinds: HashSet, pub(crate) default_mode: String, pub(crate) state: rhai::Scope<'static>, pub(crate) queues: HashMap>, @@ -188,6 +189,7 @@ impl Scope { default_mode: "default".to_string(), prefixes: HashSet::from(["".to_string()]), modes: HashSet::from(["default".to_string()]), + kinds: HashSet::new(), queues: HashMap::new(), }; } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index e52da874..7600a53d 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -126,13 +126,14 @@ use crate::define::{Define, DefineInput}; use crate::error::{ErrorContext, ErrorReport, ErrorSet, Result, ResultVec, flatten_errors}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, Value}; +use crate::kind::Kind; use crate::mode::{ModeInput, Modes}; use crate::wrn; use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; -use std::collections::{HashSet, VecDeque}; +use std::collections::{HashMap, HashSet, VecDeque}; use toml::Spanned; use wasm_bindgen::prelude::*; @@ -142,14 +143,16 @@ struct KeyFileInput { define: Option, mode: Option>>, bind: Option>>, + kind: Option>>, } #[derive(Clone, Debug, Serialize)] #[wasm_bindgen] pub struct KeyFile { define: Define, - modes: Modes, + mode: Modes, bind: Vec, + kind: HashMap, key_bind: Vec, } @@ -181,6 +184,9 @@ impl KeyFile { Ok(x) => x, }; + // [[kind]] + let kind = Kind::process(&input.kind, &mut scope)?; + // [[bind]] let input_iter = input .bind @@ -261,8 +267,9 @@ impl KeyFile { return Ok(KeyFile { define, bind, + mode: modes, + kind, key_bind: final_key_bind.into(), - modes, }); } else { return Err(errors.into()); @@ -670,7 +677,7 @@ mod tests { let result = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); assert_eq!( - result.modes.get("b").unwrap().whenNoBinding, + result.mode.get("b").unwrap().whenNoBinding, crate::mode::WhenNoBinding::UseMode("a".to_string()) ) } @@ -839,7 +846,6 @@ mod tests { let err = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); - info!("report: {report:#?}"); assert!(report[0].message.contains("statically defined")); assert_eq!(report[0].range.start.line, 12) } @@ -1062,6 +1068,7 @@ mod tests { path = "modes" name = "normal" description = "All the legacy features!" + kind = "foo" foreach.key = ["escape", "ctrl+[", "{key: [0-9]}"] combinedKey = "a/b" combinedName = "all" @@ -1077,7 +1084,34 @@ mod tests { "#; let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); - assert_eq!(warnings.errors.len(), 12); + assert_eq!(warnings.errors.len(), 13); + } + + #[test] + fn validate_kind() { + let data = r#" + [[kind]] + name = "foo" + description = "biz baz buz" + + [[bind]] + key = "a" + command = "bar" + doc.kind = "foo" + + [[bind]] + key = "b" + command = "boop" + doc.kind = "bleep" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("`bleep`")); + assert_eq!(report[0].range.start.line, 13); } // TODO: write a test for required field `key` and ensure the span diff --git a/src/rust/parsing/src/kind.rs b/src/rust/parsing/src/kind.rs new file mode 100644 index 00000000..ecce92b5 --- /dev/null +++ b/src/rust/parsing/src/kind.rs @@ -0,0 +1,68 @@ +#[allow(unused_imports)] +use log::info; + +use serde::Deserialize; +use std::collections::HashMap; +use toml::Spanned; + +use crate::err; +use crate::error::{ErrorContext, ResultVec}; +use crate::expression::Scope; + +/// @forBindingField kind +/// +/// Kind is a broad category for keybindings that is displayed as part of the visual +/// documentation for key bindings. There should be no more than 5 or so kinds, since they are +/// differentiated via colors. Furthermore, *not* knowing the kind of a keybinding +/// should never cause the meaning of a key to be ambiguous; they are meant as a visual +/// aid. +/// +/// **Example** +/// +/// ```toml +/// [[kind]] +/// name = "action" +/// +/// [[kind]] +/// name = "motion" +/// +/// [[bind]] +/// kind = "action" +/// key = "d" +/// command = "deleteLeft" +/// +/// [[bind]] +/// kind = "motion" +/// key = "l" +/// command = "cursorLeft" +/// ``` + +#[derive(Deserialize, Clone, Debug)] +pub struct Kind { + name: String, + description: String, +} + +impl Kind { + pub(crate) fn process( + input: &Option>>, + scope: &mut Scope, + ) -> ResultVec> { + let mut kinds = HashMap::new(); + if let Some(input) = input { + for kind in input.iter() { + let span = kind.span().clone(); + let kind_input = kind.as_ref(); + if kinds.contains_key(&kind_input.name) { + return Err(err!("Kind `name` must be unique.")).with_range(&span)?; + } + + kinds.insert(kind_input.name.clone(), kind_input.description.clone()); + } + scope.kinds = kinds.keys().map(|x| x.clone()).collect(); + return Ok(kinds); + } else { + return Ok(HashMap::new()); + } + } +} diff --git a/src/rust/parsing/src/lib.rs b/src/rust/parsing/src/lib.rs index 3048299d..c40feed5 100644 --- a/src/rust/parsing/src/lib.rs +++ b/src/rust/parsing/src/lib.rs @@ -6,6 +6,7 @@ mod util; // define file sections mod bind; mod define; +mod kind; mod mode; // top level parsing From 5c1ea65a1fd1a3e0a048fb3a8f19d5ed78343f2f Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 9 Oct 2025 00:56:46 -0400 Subject: [PATCH 67/79] header / file directives Created using spr 1.3.6-beta.1 --- errors.txt | 25 -- notes.md | 36 +- old_format/larkin.toml | 76 ++-- src/extension/keybindings/index.ts | 88 +++-- src/oldtest/specs/captureKeys.ux.mts | 2 +- src/oldtest/specs/configEdit.ux.mts | 6 +- src/oldtest/specs/palette.ux.mts | 4 +- src/oldtest/specs/replay.ux.mts | 2 +- src/oldtest/specs/searchMotions.ux.mts | 2 +- src/presets/larkin.toml | 2 +- src/rust/parsing/Cargo.lock | 11 + src/rust/parsing/Cargo.toml | 1 + src/rust/parsing/errors.txt | 342 ------------------ src/rust/parsing/src/bind.rs | 8 +- src/rust/parsing/src/define.rs | 4 +- src/rust/parsing/src/error.rs | 50 +-- src/rust/parsing/src/expression/value.rs | 14 +- src/rust/parsing/src/file.rs | 197 +++++++++- src/rust/parsing/src/mode.rs | 2 +- src/rust/parsing/src/util.rs | 4 +- .../test-workspace/simpleMotions.toml | 2 +- .../test-workspace/simpleMotionsLayout.toml | 2 +- .../test-workspace/textDocExample.toml | 2 +- .../test-workspace/visualDocExample.toml | 2 +- test.txt | 0 25 files changed, 373 insertions(+), 511 deletions(-) delete mode 100644 errors.txt delete mode 100644 src/rust/parsing/errors.txt create mode 100644 test.txt diff --git a/errors.txt b/errors.txt deleted file mode 100644 index dd7896c1..00000000 --- a/errors.txt +++ /dev/null @@ -1,25 +0,0 @@ -[test-rust] $ def main [...args] { - Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) -warning: use of deprecated method `indexmap::IndexMap::::remove`: `remove` disrupts the map order -- use `swap_remove` or `shift_remove` for explicit behavior. - --> src/util.rs:66:66 - | -66 | let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { - | ^^^^^^ - | - = note: `#[warn(deprecated)]` on by default - -warning: variant `Datetime` is never constructed - --> src/expression/value.rs:35:5 - | -31 | enum RawValue { - | -------- variant in this enum -... -35 | Datetime(toml::value::Datetime), - | ^^^^^^^^ - | - = note: `RawValue` has derived impls for the traits `Clone` and `Debug`, but these are intentionally ignored during dead code analysis - = note: `#[warn(dead_code)]` on by default - -warning: `parsing` (lib test) generated 2 warnings - Finished `test` profile [unoptimized + debuginfo] target(s) in 1m 09s - Running unittests src/lib.rs (target/debug/deps/parsing-8866666de8fe2650) diff --git a/notes.md b/notes.md index 89592a51..07258b46 100644 --- a/notes.md +++ b/notes.md @@ -231,13 +231,28 @@ Integration test debugging: - [X] others? - [X] implement `[[kind]]` (or redesign) - [X] add legacy check for kind (since its also in the docs) - - [ ] implement `[header]` section - - [ ] instead of using `.mk.toml`, look for a specific heading comment in the file - - [ ] remove spurious line/char positions from expression error messages - - NOTE: these come from the line and char position in the rhai expression - which has nothing to do with the line and char position in the parent - keybinding file + - [X] implement `[header]` section + - [X] instead of using `.mk.toml`, look for a specific heading comment in the file + - [X] debug error processing in `keybindings/index.ts` + - [ ] BUG: prefides defined via `master-key.prefix` are not included in + `all_prefixes` + - [ ] get rid of the `prefixes` field design and instead allow + a way to express "prefix is X" "prefix isn't X" etc... + more directly. since this wouldn't be an expression + it could be during a phase of file resolution that + already knows about the available prefixes. Like this: + ```toml + prefix.anyOf = ["a", "b", "c"] + prefix.notAnyOf = ["x", "y"] + # defaults to + prefix.anyOf = [""] + ``` + - [ ] validate that the excludes don't contain new prefixes - [ ] error handling checks + - [ ] remove spurious line/char positions from expression error messages + - NOTE: these come from the line and char position in the rhai expression + which has nothing to do with the line and char position in the parent + keybinding file - [ ] make sure a range is always provided - [ ] test that all error messages show up when expected - [ ] review coverage to verify there aren't additional checks we're missing @@ -255,8 +270,13 @@ Integration test debugging: - [ ] don't use `getter_with_clone` for `KeyFileResult` (it doesn't really make sense) - [ ] figure out how to handle ts/rust statement management - - [ ] move all bare variables in an expression to `key.` or `code.` object - - [ ] use rust scope instead of TS state object (update state.ts) + - [ ] keep command queue in rust + - [ ] probably copy simple state data to rust, duplicate + in ts for now (avoid churn) + - [ ] alternatively reimplement state.ts in rust + - [ ] move all bare variables in an expression to `key.` or `code.` object + - [ ] maybe handle state passing between commands with rust scope + object?? - [ ] properly handle command queues (now controlled by rust) - [ ] guess: don't have special command queue field - [ ] support accessing values by their path (`val.foo`, `key.count`) diff --git a/old_format/larkin.toml b/old_format/larkin.toml index 479d38a7..99652346 100644 --- a/old_format/larkin.toml +++ b/old_format/larkin.toml @@ -25,7 +25,7 @@ [header] name = "Larkin" -version = "1.0" +version = "1.0.0" requiredExtensions = [ "dbankier.vscode-quick-select", @@ -190,7 +190,10 @@ prefixes = "" path = "modes" name = "ignore" description = "this key does nothing" -foreach.key = ['{key: .}', 'shift+{key: .}'] #- all keys whose bindings are described by a single character +foreach.key = [ + '{key: .}', + 'shift+{key: .}', +] #- all keys whose bindings are described by a single character key = "{key}" command = "master-key.ignore" prefixes = "" @@ -535,7 +538,7 @@ description = "without selection: open a line above current line and enter inser key = "shift+o" when = "!editorHasSelection" command = "runCommands" -args.commands = [ "editor.action.insertLineBefore", "master-key.enterInsert" ] +args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] [[bind]] path = "edit.action.open_lines" @@ -1140,7 +1143,7 @@ key = "g c" name = "cell →" combinedName = "cell →/←" command = "runCommands" -args.commands = [ "jupyter.gotoNextCellInFile", "jupyter.selectCell" ] +args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] description = "previous jupyter notebook cell" [[bind]] @@ -1688,7 +1691,7 @@ command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", { command = "cursorMove", args = { to = "right", select = true }, computedArgs = { value = "count" } }, - "editor.action.clipboardCutAction" + "editor.action.clipboardCutAction", ] [[bind]] @@ -1721,7 +1724,11 @@ combinedDescription = "Paste clipboard before/after/at the cursor/selection" combinedKey = "p/shift+p/ctrl+p" when = "editorHasSelection" command = "runCommands" -args.commands = ["selection-utilities.activeAtEnd", "selection-utilities.shrinkToActive", "editor.action.clipboardPasteAction"] +args.commands = [ + "selection-utilities.activeAtEnd", + "selection-utilities.shrinkToActive", + "editor.action.clipboardPasteAction", +] [[bind]] path = "edit.action.clipboard" @@ -1750,7 +1757,11 @@ combinedName = "paste before/after" description = "Paste before the cursor/selection" when = "editorHasSelection" command = "runCommands" -args.commands = ["selection-utilities.activeAtStart", "selection-utilities.shrinkToActive", "editor.action.clipboardPasteAction"] +args.commands = [ + "selection-utilities.activeAtStart", + "selection-utilities.shrinkToActive", + "editor.action.clipboardPasteAction", +] [[bind]] path = "edit.action.clipboard" @@ -1789,14 +1800,14 @@ path = "edit.action.history" name = "undo" key = "u" command = "runCommands" -args.commands = [ "undo", "selection-utilities.shrinkToActive" ] +args.commands = ["undo", "selection-utilities.shrinkToActive"] [[bind]] path = "edit.action.history" name = "redo" key = "shift+u" command = "runCommands" -args.commands = [ "redo", "selection-utilities.shrinkToActive" ] +args.commands = ["redo", "selection-utilities.shrinkToActive"] [[bind]] path = "edit.action.basic" @@ -1839,8 +1850,8 @@ name = "without count: Delete from cursor to end of line; with count: Delete fro command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "wrappedLineEnd", select = true} }, - "editor.action.clipboardCutAction" + { command = "cursorMove", args = { to = "wrappedLineEnd", select = true } }, + "editor.action.clipboardCutAction", ] [[bind]] @@ -1867,7 +1878,7 @@ command = "runCommands" args.commands = [ { defined = "selectLinesDown" }, "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive" + "selection-utilities.shrinkToActive", ] [[bind]] @@ -1879,9 +1890,9 @@ when = "master-key.count <= 1" command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "wrappedLineEnd", select = true} }, + { command = "cursorMove", args = { to = "wrappedLineEnd", select = true } }, "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive" + "selection-utilities.shrinkToActive", ] [[bind]] @@ -1892,7 +1903,7 @@ command = "runCommands" args.commands = [ { defined = "selectLinesUp" }, "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive" + "selection-utilities.shrinkToActive", ] [[path]] @@ -1923,10 +1934,7 @@ name = "indent" description = "Indent lines" when = "master-key.count >= 1" command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.indentLines" -] +args.commands = [{ defined = "selectLinesDown" }, "editor.action.indentLines"] [[bind]] path = "edit.action.indent" @@ -1946,7 +1954,7 @@ command = "runCommands" args.commands = [ { defined = "selectLinesDown" }, "editor.action.outdentLines", - "selection-utilities.shrinkToActive" + "selection-utilities.shrinkToActive", ] [[path]] @@ -2200,7 +2208,7 @@ key = "space j" mode = ["normal", "selectedit"] when = "!editorHasSelection" command = "runCommands" -args.commands = [ { defined = "selectLinesDown" }, 'editor.action.joinLines' ] +args.commands = [{ defined = "selectLinesDown" }, 'editor.action.joinLines'] [[bind]] path = "edit.action.basic" @@ -2232,7 +2240,7 @@ command = "runCommands" args.commands = [ { defined = "selectLinesDown" }, "editor.action.formatSelection", - "selection-utilities.shrinkToActive" + "selection-utilities.shrinkToActive", ] [[bind]] @@ -2313,10 +2321,7 @@ combinedKey = "(shift+)/" description = "select next comment" when = "master-key.count >= 1" command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.commentLine", -] +args.commands = [{ defined = "selectLinesDown" }, "editor.action.commentLine"] [[bind]] path = "edit.action.do" @@ -2681,8 +2686,10 @@ description = "move to previous bookmark" key = "tab m k" when = "master-key.select_on || editorHasSelection" command = "runCommands" -args.commands = ["vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", - "selection-utilities.activeAtStart"] +args.commands = [ + "vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", + "selection-utilities.activeAtStart", +] [[bind]] path = "util" @@ -3195,7 +3202,8 @@ key = "c" command = "runCommands" args.commands = [ { command = "selection-utilities.appendToMemory", computedArgs = { register = "count || 'default'" } }, - "selection-utilities.shrinkToActive", "master-key.enterNormal" + "selection-utilities.shrinkToActive", + "master-key.enterNormal", ] [[bind]] @@ -3220,8 +3228,8 @@ exchange selections: with no saved selection, saves the selection, with saved se key = "x" command = "runCommands" args.commands = [ - { command = "selection-utilities.swapWithMemory", computedArgs = {register = "count || 'default'"} }, - "master-key.enterNormal" + { command = "selection-utilities.swapWithMemory", computedArgs = { register = "count || 'default'" } }, + "master-key.enterNormal", ] [[bind]] @@ -3233,8 +3241,8 @@ remove the most recently saved selection from the list of saved selections command = "runCommands" key = "n" args.commands = [ - { command = "selection-utilities.deleteLastSaved", computedArgs = {register = "count || 'default'"} }, - "master-key.enterNormal" + { command = "selection-utilities.deleteLastSaved", computedArgs = { register = "count || 'default'" } }, + "master-key.enterNormal", ] [[bind]] @@ -3530,5 +3538,5 @@ command = "runCommands" args.commands = [ "selection-utilities.shrinkToActive", { command = "master-key.setFlag", args = { name = "select_on", value = false } }, - "master-key.enterNormal" + "master-key.enterNormal", ] diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index ca121233..0f045952 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -26,7 +26,7 @@ import JSONC from 'jsonc-simple-parser'; import TOML from 'smol-toml'; // run `mise build-rust` to create this auto generated source fileu -import initParsing, { parse_keybinding_bytes } from '../../rust/parsing/lib'; +import initParsing, { ErrorLevel, parse_keybinding_bytes } from '../../rust/parsing/lib'; //////////////////////////////////////////////////////////////////////////////////////////// // Keybinding Generation @@ -640,36 +640,48 @@ async function loadPresets(allDirs: vscode.Uri[]) { let extensionPresetsDir: vscode.Uri; -async function validateKeybindings(file: vscode.Uri, fileData?: Uint8Array) { - if (file.toString().endsWith('.mk.toml')) { - if (fileData === undefined) { - fileData = await vscode.workspace.fs.readFile(file); - } - const parsed = parse_keybinding_bytes(fileData!); - if (parsed.errors) { - const diagnosticItems: vscode.Diagnostic[] = []; - for (const error of parsed.errors) { - diagnosticItems.push( - new vscode.Diagnostic( - new vscode.Range( - new vscode.Position( - error.range.start.line, - error.range.start.col, - ), - new vscode.Position( - error.range.end.line, - error.range.end.col, - ), +async function validateKeybindings( + file: vscode.Uri, + fileData?: Uint8Array, + implicit: boolean = true, +) { + if (fileData === undefined) { + fileData = await vscode.workspace.fs.readFile(file); + } + const parsed = parse_keybinding_bytes(fileData!); + if (implicit && + parsed.errors && + parsed.errors[0]?.message && + /#:master-keybindings/.test(parsed.errors[0].message)) { + return diagnostics.delete(file); + } + if (parsed.errors) { + const diagnosticItems: vscode.Diagnostic[] = []; + for (const error of parsed.errors) { + diagnosticItems.push( + new vscode.Diagnostic( + new vscode.Range( + new vscode.Position( + error.range.start.line, + error.range.start.col, + ), + new vscode.Position( + error.range.end.line, + error.range.end.col, ), - error.message, - vscode.DiagnosticSeverity.Error, ), - ); - } - diagnostics.set(file, diagnosticItems); - } else { - diagnostics.delete(file); + error.message, + error.level == ErrorLevel.Error ? + vscode.DiagnosticSeverity.Error : + error.level == ErrorLevel.Warn ? + vscode.DiagnosticSeverity.Warning : + vscode.DiagnosticSeverity.Hint, + ), + ); } + diagnostics.set(file, diagnosticItems); + } else { + diagnostics.delete(file); } } @@ -683,18 +695,24 @@ export async function activate(context: vscode.ExtensionContext) { const encoder = new TextEncoder(); vscode.workspace.onDidChangeTextDocument(async (e) => { - debounce(() => { - const text = e.document.getText(); - const bytes = encoder.encode(text); - validateKeybindings(e.document.uri, bytes); - }, 1000)(); + if (e.document.languageId == 'toml') { + debounce(() => { + const text = e.document.getText(); + const bytes = encoder.encode(text); + validateKeybindings(e.document.uri, bytes); + }, 1000)(); + } }); vscode.workspace.onDidSaveTextDocument(async (e) => { - await validateKeybindings(e.uri); + if (e.languageId == 'toml') { + await validateKeybindings(e.uri); + } }); vscode.workspace.onDidOpenTextDocument(async (e) => { - await validateKeybindings(e.uri); + if (e.languageId == 'toml') { + await validateKeybindings(e.uri); + } }); // initialize rust WASM module for parsing keybinding files diff --git a/src/oldtest/specs/captureKeys.ux.mts b/src/oldtest/specs/captureKeys.ux.mts index 74a26110..1fb593a9 100644 --- a/src/oldtest/specs/captureKeys.ux.mts +++ b/src/oldtest/specs/captureKeys.ux.mts @@ -18,7 +18,7 @@ describe('Search motion command', () => { before(async () => { await setBindings(` [header] - version = "2.0" + version = "2.0.0" [[bind]] description = "Enter normal mode" diff --git a/src/oldtest/specs/configEdit.ux.mts b/src/oldtest/specs/configEdit.ux.mts index ea4d3b41..5ae5ea0b 100644 --- a/src/oldtest/specs/configEdit.ux.mts +++ b/src/oldtest/specs/configEdit.ux.mts @@ -47,7 +47,7 @@ describe('Configuration Editing', () => { console.log('[DEBUG]: setting bindings'); await setBindings(` [header] - version = "2.0" + version = "2.0.0" name = "Some Bindings" [[bind]] @@ -60,7 +60,7 @@ describe('Configuration Editing', () => { console.log('[DEBUG]: creating new binding setup'); const bindingEditor = await setupEditor(` [header] - version = "2.0" + version = "2.0.0" name = "Some New Bindings" [[bind]] @@ -94,7 +94,7 @@ describe('Configuration Editing', () => { // ensure the coverage command is available await setBindings(` [header] - version = "2.0" + version = "2.0.0" `); diff --git a/src/oldtest/specs/palette.ux.mts b/src/oldtest/specs/palette.ux.mts index 5b5fb83e..6c1c1c62 100644 --- a/src/oldtest/specs/palette.ux.mts +++ b/src/oldtest/specs/palette.ux.mts @@ -19,7 +19,7 @@ describe('Palette', () => { before(async () => { await setBindings(` [header] - version = "2.0" + version = "2.0.0" [[mode]] name = "insert" @@ -166,7 +166,7 @@ describe('Palette', () => { await sleep(1000); await setBindings(` [header] - version = "2.0" + version = "2.0.0" [[mode]] name = "insert" diff --git a/src/oldtest/specs/replay.ux.mts b/src/oldtest/specs/replay.ux.mts index 7b69b61d..79bb239f 100644 --- a/src/oldtest/specs/replay.ux.mts +++ b/src/oldtest/specs/replay.ux.mts @@ -17,7 +17,7 @@ describe('Replay', () => { before(async () => { await setBindings(` [header] - version = "2.0" + version = "2.0.0" [[mode]] name = "insert" diff --git a/src/oldtest/specs/searchMotions.ux.mts b/src/oldtest/specs/searchMotions.ux.mts index b8e11b64..9420f788 100644 --- a/src/oldtest/specs/searchMotions.ux.mts +++ b/src/oldtest/specs/searchMotions.ux.mts @@ -18,7 +18,7 @@ describe('Search motion command', () => { before(async () => { await setBindings(` [header] - version = "2.0" + version = "2.0.0" [[mode]] name = "insert" diff --git a/src/presets/larkin.toml b/src/presets/larkin.toml index 50234952..1aab6288 100644 --- a/src/presets/larkin.toml +++ b/src/presets/larkin.toml @@ -27,7 +27,7 @@ [header] name = "Larkin" -version = "2.0" +version = "2.0.0" requiredExtensions = [ "dbankier.vscode-quick-select", diff --git a/src/rust/parsing/Cargo.lock b/src/rust/parsing/Cargo.lock index 5d00bb1e..2306dd52 100644 --- a/src/rust/parsing/Cargo.lock +++ b/src/rust/parsing/Cargo.lock @@ -358,6 +358,7 @@ dependencies = [ "log", "regex", "rhai", + "semver", "serde", "serde-wasm-bindgen", "serde_spanned", @@ -504,6 +505,16 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +dependencies = [ + "serde", + "serde_core", +] + [[package]] name = "serde" version = "1.0.226" diff --git a/src/rust/parsing/Cargo.toml b/src/rust/parsing/Cargo.toml index 6aab0137..ea0c4c5a 100644 --- a/src/rust/parsing/Cargo.toml +++ b/src/rust/parsing/Cargo.toml @@ -30,6 +30,7 @@ instant = { version = "0.1.13", features = ["wasm-bindgen"] } smallvec = { version = "1.15.1", features = ["serde"] } serde_spanned = "1.0.2" toml_datetime = "0.7.2" +semver = { version = "1.0.27", features = ["serde"] } [lib] crate-type = ["cdylib"] diff --git a/src/rust/parsing/errors.txt b/src/rust/parsing/errors.txt deleted file mode 100644 index 57829db5..00000000 --- a/src/rust/parsing/errors.txt +++ /dev/null @@ -1,342 +0,0 @@ -[test-rust] $ def main [...args] { - Compiling parsing v0.1.0 (/Users/davidlittle/Documents/home/vscode-master-key/src/rust/parsing) - Finished `test` profile [unoptimized + debuginfo] target(s) in 26.36s - Running unittests src/lib.rs (target/debug/deps/parsing-4b199d9df4c1bd45) - -thread 'bind::tests::complete_parsing' panicked at src/bind.rs:644:59: -called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `do`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"do\"\n args = { a = \"2\", b = 3 }\n key = \"a\"\n when = \"joe > 1\"\n mode = \"normal\"\n priority = 1\n default = \"{{bind.foo_bar}}\"\n foreach.index = [1,2,3]\n prefixes = \"c\"\n finalKey = true\n repeat = \"{{2+c}}\"\n tags = [\"foo\", \"bar\"]\n doc.name = \"foo\"\n doc.description = \"foo bar bin\"\n doc.hideInPalette = false\n doc.hideInDocs = false\n doc.combinedName = \"Up/down\"\n doc.combinedKey = \"A/B\"\n doc.combinedDescription = \"bla bla bla\"\n doc.kind = \"biz\"\n "), keys: ["command"], span: Some(19..23) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::complete_parsing - at ./src/bind.rs:644:59 - 5: parsing::bind::tests::complete_parsing::{{closure}} - at ./src/bind.rs:620:26 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::command::tests::command_is_required' panicked at src/bind/command.rs:319:57: -called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"runCommands\"\n\n [[args.commands]]\n command = \"a\"\n\n [[args.commands]]\n args = { foo = 1, bar = 2 }\n "), keys: ["command"], span: Some(19..32) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::command::tests::command_is_required - at ./src/bind/command.rs:319:57 - 5: parsing::bind::command::tests::command_is_required::{{closure}} - at ./src/bind/command.rs:308:29 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::command::tests::parse_regularize_commands' panicked at src/bind/command.rs:275:57: -called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n command = \"runCommands\"\n\n [[args.commands]]\n command = \"a\"\n\n [[args.commands]]\n command = \"b\"\n args = { foo = 1, bar = 2 }\n\n [[args.commands]]\n command = \"c\"\n args = [1,2]\n skipWhen = \"{{count > 2}}\"\n "), keys: ["command"], span: Some(19..32) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::command::tests::parse_regularize_commands - at ./src/bind/command.rs:275:57 - 5: parsing::bind::command::tests::parse_regularize_commands::{{closure}} - at ./src/bind/command.rs:258:35 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::merge_nested_arguments' panicked at src/bind.rs:814:81: -called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `default`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n [[bind]]\n doc.name = \"default\"\n command = \"cursorMove\"\n args.foo = { a = 2, b = 3, c = { x = 1 } }\n\n [[bind]]\n key = \"r\"\n doc.name = \"→\"\n args.foo = { d = 12, c = { y = 2 } }\n\n [[bind]]\n key = \"x\"\n doc.name = \"expected\"\n args.foo = { a = 2, b = 3, c = { x = 1, y = 2 }, d = 12 }\n "), keys: ["bind", "doc", "name"], span: Some(45..54) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::merge_nested_arguments - at ./src/bind.rs:814:81 - 5: parsing::bind::tests::merge_nested_arguments::{{closure}} - at ./src/bind.rs:796:32 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'define::tests::simple_parsing' panicked at src/define.rs:337:70: -called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `bill`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[val]]\n y = \"bill\"\n\n [[bind]]\n id = \"foo\"\n key = \"x\"\n command = \"foo\"\n args = { k = 1, h = 2 }\n\n [[command]]\n id = \"foobar\"\n command = \"runCommands\"\n args.commands = [\"foo\", \"bar\"]\n\n [[val]]\n joe = \"bob\"\n\n "), keys: ["val", "y"], span: Some(29..35) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::define::tests::simple_parsing - at ./src/define.rs:337:70 - 5: parsing::define::tests::simple_parsing::{{closure}} - at ./src/define.rs:316:24 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::expand_foreach_keys' panicked at src/bind.rs:917:59: -called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["foreach", "key"], span: Some(28..47) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::expand_foreach_keys - at ./src/bind.rs:917:59 - 5: parsing::bind::tests::expand_foreach_keys::{{closure}} - at ./src/bind.rs:909:29 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::default_parsing' panicked at src/bind.rs:727:59: -called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `cursorMove`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n key = \"l\"\n command = \"cursorMove\"\n args.to = \"left\"\n "), keys: ["command"], span: Some(37..49) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::default_parsing - at ./src/bind.rs:727:59 - 5: parsing::bind::tests::default_parsing::{{closure}} - at ./src/bind.rs:720:25 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'file::tests::resolve_bind_and_command' panicked at src/file.rs:272:72: -called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `bizbaz`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n\n [[define.val]]\n foo_string = \"bizbaz\"\n\n [[define.command]]\n id = \"run_shebang\"\n command = \"shebang\"\n args.a = 1\n args.b = \"{{val.foo_string}}\"\n\n [[define.bind]]\n id = \"whole_shebang\"\n doc.name = \"the whole shebang\"\n command = \"runCommands\"\n args.commands = [\"{{command.run_shebang}}\", \"bar\"]\n\n [[bind]]\n default = \"{{bind.whole_shebang}}\"\n key = \"a\"\n "), keys: ["define", "val", "foo_string"], span: Some(46..54) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::resolve_bind_and_command - at ./src/file.rs:272:72 - 5: parsing::file::tests::resolve_bind_and_command::{{closure}} - at ./src/file.rs:249:34 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::simple_command_merging' panicked at src/bind.rs:765:81: -called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `default`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n [[bind]]\n doc.name = \"default\"\n command = \"cursorMove\"\n prefixes = [\"a\"]\n\n [[bind]]\n key = \"l\"\n doc.name = \"←\"\n args.to = \"left\"\n prefixes = [\"b\", \"c\"]\n "), keys: ["bind", "doc", "name"], span: Some(37..46) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::simple_command_merging - at ./src/bind.rs:765:81 - 5: parsing::bind::tests::simple_command_merging::{{closure}} - at ./src/bind.rs:751:32 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::merge_nested_array_arguments' panicked at src/bind.rs:865:81: -called `Result::unwrap()` on an `Err` value: Error { message: "while parsing toml: first error: while parsing toml: unknown variant `runCommands`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n\n", input: Some("\n [[bind]]\n name = \"default\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args.b = \"bar\"\n\n [[bind.args.commands]]\n command = \"step2\"\n args.x = \"biz\"\n\n [[bind]]\n name = \"run\"\n key = \"x\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args.a = \"foo\"\n\n [[bind.args.commands]]\n command = \"step2\"\n args.y = \"fiz\"\n\n [[bind]]\n name = \"run_merged\"\n key = \"x\"\n command = \"runCommands\"\n\n [[bind.args.commands]]\n command = \"step1\"\n args = {a = \"foo\", b = \"bar\"}\n\n [[bind.args.commands]]\n command = \"step2\"\n args = {x = \"biz\", y = \"fiz\"}\n "), keys: ["bind", "command"], span: Some(73..86) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::merge_nested_array_arguments - at ./src/bind.rs:865:81 - 5: parsing::bind::tests::merge_nested_array_arguments::{{closure}} - at ./src/bind.rs:824:38 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'file::tests::resolve_nested_command' panicked at src/file.rs:320:72: -called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `run_shebang`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n\n [[define.command]]\n id = \"run_shebang\"\n command = \"shebang\"\n args.a = 1\n args.b = \"{{val.foo_string}}\"\n\n [[define.bind]]\n id = \"a\"\n args.commands = [\"{{command.run_shebang}}\", \"bar\"]\n\n [[define.bind]]\n id = \"b\"\n key = \"x\"\n command = \"runCommands\"\n default = \"{{bind.a}}\"\n\n [[bind]]\n default = \"{{bind.b}}\"\n doc.name = \"the whole shebang\"\n key = \"a\"\n "), keys: ["define", "command", "id"], span: Some(42..55) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::resolve_nested_command - at ./src/file.rs:320:72 - 5: parsing::file::tests::resolve_nested_command::{{closure}} - at ./src/file.rs:295:32 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'file::tests::expand_foreach' panicked at src/file.rs:353:72: -called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[bind]]\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n key = \"c {{key}}\"\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["bind", "foreach", "key"], span: Some(41..60) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::expand_foreach - at ./src/file.rs:353:72 - 5: parsing::file::tests::expand_foreach::{{closure}} - at ./src/file.rs:343:24 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'file::tests::foreach_error' panicked at src/file.rs:383:72: -called `Result::unwrap()` on an `Err` value: Error { message: "unknown variant `{{keys(`[0-9]`)}}`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[bind]]\n foreach.key = [\"{{keys(`[0-9]`)}}\"]\n doc.name = \"update {{key}}\"\n command = \"foo\"\n args.value = \"{{key}}\"\n "), keys: ["bind", "foreach", "key"], span: Some(41..60) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::foreach_error - at ./src/file.rs:383:72 - 5: parsing::file::tests::foreach_error::{{closure}} - at ./src/file.rs:373:23 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'file::tests::parse_example' panicked at src/file.rs:240:58: -called `Result::unwrap()` on an `Err` value: ErrorSet { errors: [Error { error: TomlParsing(Error { message: "unknown variant `bar`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`", input: Some("\n [[define.val]]\n foo = \"bar\"\n\n [[bind]]\n key = \"l\"\n mode = \"normal\"\n command = \"cursorRight\"\n\n [[bind]]\n key = \"h\"\n model = \"normal\"\n command = \"cursorLeft\"\n "), keys: ["define", "val", "foo"], span: Some(38..43) }), contexts: [] }] } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::file::tests::parse_example - at ./src/file.rs:240:58 - 5: parsing::file::tests::parse_example::{{closure}} - at ./src/file.rs:224:23 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::expands_foreach' panicked at src/bind.rs:884:59: -called `Result::unwrap()` on an `Err` value: Error { message: "wanted string or table", input: Some("\n foreach.a = [1, 2]\n foreach.b = [\"x\", \"y\"]\n doc.name = \"test {{a}}-{{b}}\"\n command = \"run-{{a}}\"\n args.value = \"with-{{b}}\"\n "), keys: ["foreach", "a"], span: Some(26..27) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::expands_foreach - at ./src/bind.rs:884:59 - 5: parsing::bind::tests::expands_foreach::{{closure}} - at ./src/bind.rs:875:25 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. - -thread 'bind::tests::expand_args' panicked at src/bind.rs:948:58: -called `Result::unwrap()` on an `Err` value: Error { message: "first error: while parsing toml: unknown variant `test`, expected one of `Integer`, `Float`, `String`, `Datetime`, `Boolean`, `Array`, `Table`\n", input: Some("\n key = \"k\"\n doc.name = \"test\"\n command = \"foo\"\n args.value = '{{joe + \"_biz\"}}'\n args.number = '{{2+1}}'\n "), keys: ["doc", "name"], span: Some(46..52) } -stack backtrace: - 0: __rustc::rust_begin_unwind - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/std/src/panicking.rs:697:5 - 1: core::panicking::panic_fmt - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/panicking.rs:75:14 - 2: core::result::unwrap_failed - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1761:5 - 3: core::result::Result::unwrap - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/result.rs:1167:23 - 4: parsing::bind::tests::expand_args - at ./src/bind.rs:948:58 - 5: parsing::bind::tests::expand_args::{{closure}} - at ./src/bind.rs:939:21 - 6: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 - 7: core::ops::function::FnOnce::call_once - at /rustc/29483883eed69d5fb4db01964cdf2af4d86e9cb2/library/core/src/ops/function.rs:250:5 -note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace. -error: test failed, to rerun pass `--lib` -[test-rust] ERROR task failed diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index d413544a..fd0b2b53 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -257,7 +257,13 @@ impl BindingInput { if let TypedValue::Constant(prefixes) = input.as_ref().prefixes.as_ref() { let explicit_prefixes: Vec = prefixes.clone().resolve("prefixes", scope).unwrap(); - let key_sequence: String = input.as_ref().key.clone().resolve("`key`", scope)?; + let span = input.span().clone(); + let key_sequence: String = input + .as_ref() + .key + .clone() + .resolve("key", scope) + .with_range(&span)?; if explicit_prefixes.len() > 0 { for p in explicit_prefixes { let seq = WHITESPACE.split(&p).chain(WHITESPACE.split(&key_sequence)); diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index add7c4df..c74a93e6 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -13,7 +13,7 @@ use crate::bind::BindingInput; use crate::bind::command::CommandInput; use crate::bind::validation::BindingReference; use crate::err; -use crate::error::{Error, ErrorContext, ResultVec, err}; +use crate::error::{ErrorContext, ParseError, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, Value}; use crate::util::{Merging, Resolving}; @@ -189,7 +189,7 @@ impl Define { let mut resolved_bind = HashMap::::new(); let mut resolved_command = HashMap::::new(); let mut resolved_var = HashMap::::new(); - let mut errors: Vec = Vec::new(); + let mut errors: Vec = Vec::new(); for def_block in input.val.into_iter().flatten() { for (val, value) in def_block.into_iter() { diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 669fa93e..630e6e46 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -47,7 +47,7 @@ macro_rules! err { #[macro_export] macro_rules! wrn { ( $($x:tt)* ) => { - crate::error::Error { + crate::error::ParseError { error: crate::error::RawError::Dynamic(format!($($x)*)), contexts: smallvec::SmallVec::new(), level: crate::error::ErrorLevel::Warn, @@ -58,7 +58,7 @@ macro_rules! wrn { #[macro_export] macro_rules! note { ( $($x:tt)* ) => { - crate::error::Error { + crate::error::ParseError { error: crate::error::RawError::Dynamic(format!($($x)*)) contexts: smallvec::SmallVec::new(), level: crate::error::ErrorLevel::Note @@ -70,16 +70,16 @@ pub fn err(msg: &'static str) -> RawError { return RawError::Static(msg); } -pub fn wrn(msg: &'static str) -> Error { - return Error { +pub fn wrn(msg: &'static str) -> ParseError { + return ParseError { error: RawError::Static(msg), contexts: SmallVec::new(), level: ErrorLevel::Warn, }; } -pub fn note(msg: &'static str) -> Error { - return Error { +pub fn note(msg: &'static str) -> ParseError { + return ParseError { error: RawError::Static(msg), contexts: SmallVec::new(), level: ErrorLevel::Info, @@ -88,7 +88,7 @@ pub fn note(msg: &'static str) -> Error { #[wasm_bindgen] #[derive(Debug, Error, Clone)] -pub struct Error { +pub struct ParseError { #[source] pub(crate) error: RawError, pub(crate) contexts: SmallVec<[Context; 8]>, @@ -172,13 +172,13 @@ where } impl ErrorContext for Result { - type Error = Error; + type Error = ParseError; fn with_context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), Err(mut e) => { e.contexts.push(context); - Err(Error { + Err(ParseError { error: e.error, contexts: e.contexts, level: e.level, @@ -188,11 +188,11 @@ impl ErrorContext for Result { } } -pub type Result = std::result::Result; +pub type Result = std::result::Result; -impl> From for Error { +impl> From for ParseError { fn from(error: E) -> Self { - return Error { + return ParseError { error: error.into(), contexts: SmallVec::new(), level: ErrorLevel::default(), @@ -200,8 +200,8 @@ impl> From for Error { } } -impl From> for Error { - fn from(value: Box) -> Error { +impl From> for ParseError { + fn from(value: Box) -> ParseError { return RawError::Dynamic(value.to_string()).into(); } } @@ -219,11 +219,11 @@ pub type ResultVec = std::result::Result; #[derive(Debug, Clone, Error)] #[error("first error: {}", .errors[0])] pub struct ErrorSet { - pub(crate) errors: Vec, + pub(crate) errors: Vec, } -impl From for ErrorSet { - fn from(value: Error) -> Self { +impl From for ErrorSet { + fn from(value: ParseError) -> Self { return ErrorSet { errors: vec![value], }; @@ -239,7 +239,7 @@ where let flat_errs = errors .into_iter() .flat_map(|x| x.unwrap_err().errors.into_iter()) - .collect::>(); + .collect::>(); if flat_errs.len() > 0 { return Err(flat_errs.into()); @@ -251,26 +251,26 @@ where impl> From for ErrorSet { fn from(error: E) -> Self { let error: RawError = error.into(); - let error: Error = error.into(); + let error: ParseError = error.into(); return error.into(); } } -impl From> for ErrorSet { - fn from(value: Vec) -> Self { +impl From> for ErrorSet { + fn from(value: Vec) -> Self { return ErrorSet { errors: value }; } } impl> ErrorContext for std::result::Result { - type Error = Error; + type Error = ParseError; fn with_context(self, context: Context) -> Result { return match self { Ok(x) => Ok(x), Err(e) => { let mut contexts = SmallVec::new(); contexts.push(context); - Err(Error { + Err(ParseError { error: e.into(), contexts, level: ErrorLevel::default(), @@ -301,7 +301,7 @@ impl ErrorContext for ResultVec { // While this trait might be useful for debugging it is not the main API through which // errors are reported. It has to be implemented for `derive(Error)` to work -impl fmt::Display for Error { +impl fmt::Display for ParseError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> { for context in &self.contexts { match context { @@ -354,7 +354,7 @@ fn resolve_rhai_pos_from_expression_range( } #[wasm_bindgen] -impl Error { +impl ParseError { /// `report` is how we generate legible annotations /// of *.mk.toml file errors in typescript pub fn report(&self, content: &[u8]) -> ErrorReport { diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index b562700e..5b2448ee 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -15,7 +15,7 @@ use toml::Spanned; use crate::bind::UNKNOWN_RANGE; use crate::err; -use crate::error::{Error, ErrorContext, ErrorSet, Result, ResultVec, err, flatten_errors}; +use crate::error::{ErrorContext, ErrorSet, ParseError, Result, ResultVec, err, flatten_errors}; use crate::expression::Scope; use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; @@ -52,7 +52,7 @@ pub enum Value { pub struct Expression { pub content: String, #[serde(skip)] - pub error: Option, // parsing-time error that we want to report after deserializing + pub error: Option, // parsing-time error that we want to report after deserializing pub span: Range, pub scope: SmallVec<[(String, BareValue); 8]>, } @@ -273,7 +273,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match let content: String = m.as_str().into(); let mut error = None; if content.contains("{{") { - error = Some(Error { + error = Some(ParseError { error: err("unexpected `{{`"), contexts: smallvec![crate::error::Context::Range(exp_span.clone())], level: crate::error::ErrorLevel::Error, @@ -289,7 +289,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match let content: String = m.as_str().into(); let mut error = None; if content.contains("{{") { - error = Some(Error { + error = Some(ParseError { error: err("unexpected `{{`"), contexts: smallvec![], level: crate::error::ErrorLevel::Error, @@ -306,7 +306,7 @@ fn match_to_expression(maybe_parent_span: &Option>, m: regex::Match fn check_unmatched_braces(x: String, span: Option>) -> Value { if x.contains("{{") { - let mut error: Error = err("unexpected `{{`").into(); + let mut error: ParseError = err("unexpected `{{`").into(); if let Some(r) = span.clone() { error.contexts.push(crate::error::Context::Range(r)); }; @@ -317,7 +317,7 @@ fn check_unmatched_braces(x: String, span: Option>) -> Value { scope: SmallVec::new(), }); } else if x.contains("}}") { - let mut error: Error = err("unexpected `}}`").into(); + let mut error: ParseError = err("unexpected `}}`").into(); if let Some(r) = span.clone() { error.contexts.push(crate::error::Context::Range(r.clone())); }; @@ -493,7 +493,7 @@ impl From for Dynamic { } impl TryFrom for Value { - type Error = crate::error::Error; + type Error = crate::error::ParseError; // TODO: this is currently almost certainly quite inefficient (we clone arrays and // maps), but we can worry about optimizing this later fn try_from(value: Dynamic) -> Result { diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 7600a53d..21783836 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -23,7 +23,7 @@ /// ```toml /// [header] /// # this denotes the file-format version, it must be semver compatible with 2.0 -/// version = "2.0" +/// version = "2.0.0" /// name = "My Bindings" /// /// [[mode]] @@ -128,10 +128,11 @@ use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, Value}; use crate::kind::Kind; use crate::mode::{ModeInput, Modes}; -use crate::wrn; +use crate::{err, wrn}; use lazy_static::lazy_static; use regex::Regex; +use semver::{Version, VersionReq}; use serde::{Deserialize, Serialize}; use std::collections::{HashMap, HashSet, VecDeque}; use toml::Spanned; @@ -140,12 +141,18 @@ use wasm_bindgen::prelude::*; // TODO: copy over docs from typescript #[derive(Deserialize, Clone, Debug)] struct KeyFileInput { + header: Header, define: Option, mode: Option>>, bind: Option>>, kind: Option>>, } +#[derive(Deserialize, Clone, Debug)] +struct Header { + version: Spanned, +} + #[derive(Clone, Debug, Serialize)] #[wasm_bindgen] pub struct KeyFile { @@ -162,6 +169,16 @@ impl KeyFile { fn new(input: KeyFileInput, mut scope: &mut Scope) -> ResultVec { let mut errors = Vec::new(); + // [header] + let version = input.header.version.as_ref(); + if !VersionReq::parse("2.0").unwrap().matches(version) { + let r: Result<()> = Err(wrn!( + "This version of master key is only compatible with the 2.0 file format." + )) + .with_range(&input.header.version.span()); + errors.push(r.unwrap_err().into()); + } + // [[define]] let define_input = input.define.unwrap_or_default(); let mut define = match Define::new(define_input, &mut scope) { @@ -289,7 +306,13 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { return match parse_bytes_helper(&file_content) { Ok((result, warnings)) => KeyFileResult { file: Some(result), - errors: None, + errors: Some( + warnings + .errors + .iter() + .map(|e| e.report(&file_content)) + .collect(), + ), }, Err(err) => KeyFileResult { file: None, @@ -299,7 +322,39 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { } fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { + // ensure there's a directive + // we know that the content was converted from a string on the typescript side + // so we're cool with an unchecked conversion + // TODO: maybe we implement this check in typescript?? + let has_directive: bool = { + let mut result: bool = false; + let skip_line = Regex::new(r"\s*(#.*)?").unwrap(); + let lines = unsafe { str::from_utf8_unchecked(file_content).lines() }; + for line in lines { + if !skip_line.is_match(line) { + break; + } + if Regex::new(r"^\s*#:master-keybindings\s*$") + .unwrap() + .is_match(line) + { + result = true; + break; + } + } + result + }; + if !has_directive { + Err(err!( + "To be treated as a master keybindings file, the TOML document must \ + include the directive `#:master-keybindings` on a line by itself + before any TOML data." + )) + .with_range(&(0..0))?; + } + let parsed = toml::from_slice::(file_content)?; + let mut scope = Scope::new(); // TODO: do something with this scope?? let bind = parsed.bind.clone(); let result = KeyFile::new(parsed, &mut scope); @@ -397,6 +452,11 @@ mod tests { #[test] fn parse_example() { let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + [[define.val]] foo = "bar" @@ -423,9 +483,48 @@ mod tests { assert_eq!(result.bind[1].commands[0].command, "cursorLeft"); } + #[test] + fn validate_version() { + let data = r#" + [header] + version = "1.0.0" + + [[bind]] + key = "a" + command = "foo" + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("version")); + assert_eq!(report[0].range.start.line, 2); + } + + #[test] + fn validate_comment_directive() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "b" + "#; + + let err = parse_bytes_helper(data.as_bytes()).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("directive")); + assert_eq!(report[0].range.start.line, 0); + } + #[test] fn resolve_bind_and_command() { let data = r#" + [header] + version = "2.0.0" + [[define.val]] foo_string = "bizbaz" @@ -475,6 +574,9 @@ mod tests { #[test] fn resolve_nested_command() { let data = r#" + [header] + version = "2.0.0" + [[define.command]] id = "run_shebang" @@ -526,6 +628,9 @@ mod tests { #[test] fn expand_foreach() { let data = r#" + [header] + version = "2.0.0" + [[bind]] foreach.key = ["{{keys(`[0-9]`)}}"] key = "c {{key}}" @@ -566,6 +671,9 @@ mod tests { #[test] fn foreach_error() { let data = r#" + [header] + version = "2.0.0" + [[bind]] foreach.key = ["{{keys(`[0-9]`)}}"] doc.name = "update {{key}}" @@ -578,13 +686,16 @@ mod tests { let result = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope); let report = result.unwrap_err().report(data.as_bytes()); assert_eq!(report[0].message, "`key` field is required".to_string()); - assert_eq!(report[0].range.start.line, 1); - assert_eq!(report[0].range.end.line, 1); + assert_eq!(report[0].range.start.line, 4); + assert_eq!(report[0].range.end.line, 4); } #[test] fn define_val_at_read() { let data = r#" + [header] + version = "2.0.0" + [[define.val]] foo = "bar" @@ -603,6 +714,9 @@ mod tests { #[test] fn just_one_default_mode() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -617,12 +731,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("default mode already set")); - assert_eq!(report[0].range.start.line, 5) + assert_eq!(report[0].range.start.line, 8) } #[test] fn includes_default_mode() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" @@ -639,12 +756,15 @@ mod tests { .message .contains("exactly one mode must be the default") ); - assert_eq!(report[0].range.start.line, 0) + assert_eq!(report[0].range.start.line, 4) } #[test] fn unique_mode_name() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -658,12 +778,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode name is not unique")); - assert_eq!(report[0].range.start.line, 5) + assert_eq!(report[0].range.start.line, 8) } #[test] fn parse_use_mode() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -685,6 +808,9 @@ mod tests { #[test] fn validate_use_mode() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -699,12 +825,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `c` is not defined")); - assert_eq!(report[0].range.start.line, 7) + assert_eq!(report[0].range.start.line, 10) } #[test] fn eval_mode_expressions() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -740,6 +869,9 @@ mod tests { #[test] fn validate_mode_expressions() { let data = r#" + [header] + version = "2.0.0" + [[mode]] name = "a" default = true @@ -761,12 +893,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `d`")); - assert_eq!(report[0].range.start.line, 14) + assert_eq!(report[0].range.start.line, 17) } #[test] fn eval_prefix_expressions() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a b c" command = "foo" @@ -803,6 +938,9 @@ mod tests { #[test] fn validate_prefix_expressions() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a b c" command = "foo" @@ -822,12 +960,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("prefix `d k`")); - assert_eq!(report[0].range.start.line, 12) + assert_eq!(report[0].range.start.line, 15) } #[test] fn validate_prefixes_are_static() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a b c" command = "foo" @@ -847,12 +988,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("statically defined")); - assert_eq!(report[0].range.start.line, 12) + assert_eq!(report[0].range.start.line, 15) } #[test] fn command_expansion() { let data = r#" + [header] + version = "2.0.0" + [[define.val]] flag = true bar = "test" @@ -896,6 +1040,9 @@ mod tests { #[test] fn command_expansion_validates_final_key() { let data = r#" + [header] + version = "2.0.0" + [[define.val]] flag = true bar = "test" @@ -928,12 +1075,15 @@ mod tests { KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("`finalKey`")); - assert_eq!(report[0].range.start.line, 10); + assert_eq!(report[0].range.start.line, 13); } #[test] fn command_expansion_dynamically_validates_final_key() { let data = r#" + [header] + version = "2.0.0" + [[define.val]] flag = true bar = "test" @@ -971,6 +1121,9 @@ mod tests { #[test] fn output_bindings_overwrite_implicit_prefix() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a b" command = "foo" @@ -1018,6 +1171,9 @@ mod tests { #[test] fn output_bindings_identify_duplicates() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a k" command = "bob" @@ -1038,13 +1194,16 @@ mod tests { let report = err.report(data.as_bytes()); assert!(report[0].message.contains("Duplicate key")); - assert_eq!(report[0].range.start.line, 10); - assert_eq!(report[1].range.start.line, 1); + assert_eq!(report[0].range.start.line, 13); + assert_eq!(report[1].range.start.line, 4); } #[test] fn output_bindings_expand_prefixes() { let data = r#" + [header] + version = "2.0.0" + [[bind]] key = "a b" command = "foo" @@ -1060,6 +1219,9 @@ mod tests { #[test] fn raises_legacy_warnings() { let data = r#" + [header] + version = "2.0.0" + [[path]] id = "modes" description = "foo bar" @@ -1090,6 +1252,9 @@ mod tests { #[test] fn validate_kind() { let data = r#" + [header] + version = "2.0.0" + [[kind]] name = "foo" description = "biz baz buz" @@ -1111,7 +1276,7 @@ mod tests { let report = err.report(data.as_bytes()); assert!(report[0].message.contains("`bleep`")); - assert_eq!(report[0].range.start.line, 13); + assert_eq!(report[0].range.start.line, 16); } // TODO: write a test for required field `key` and ensure the span diff --git a/src/rust/parsing/src/mode.rs b/src/rust/parsing/src/mode.rs index 7b743233..e50c5520 100644 --- a/src/rust/parsing/src/mode.rs +++ b/src/rust/parsing/src/mode.rs @@ -214,7 +214,7 @@ impl Modes { let mut default_mode = None; let mut first_mode_span = UNKNOWN_RANGE; for mode in &input { - if first_mode_span != UNKNOWN_RANGE { + if first_mode_span == UNKNOWN_RANGE { first_mode_span = mode.span().clone(); } let mode_name = mode.as_ref().name.clone(); diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index efbe271b..79c098a6 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -7,7 +7,7 @@ use std::collections::HashMap; use toml::{Spanned, Value}; use crate::err; -use crate::error::{Error, ErrorContext, Result, ResultVec, flatten_errors}; +use crate::error::{ErrorContext, ParseError, Result, ResultVec, flatten_errors}; use crate::expression::Scope; // @@ -309,7 +309,7 @@ impl<'de, T> TryFrom> for Required where T: Deserialize<'de>, { - type Error = Error; + type Error = ParseError; fn try_from(value: Option) -> Result { match value { Option::None => Ok(Required::DefaultValue), diff --git a/src/test/integration/test-workspace/simpleMotions.toml b/src/test/integration/test-workspace/simpleMotions.toml index 4d0b475f..706d29b7 100644 --- a/src/test/integration/test-workspace/simpleMotions.toml +++ b/src/test/integration/test-workspace/simpleMotions.toml @@ -1,5 +1,5 @@ [header] -version = "2.0" +version = "2.0.0" [[mode]] name = "insert" diff --git a/src/test/integration/test-workspace/simpleMotionsLayout.toml b/src/test/integration/test-workspace/simpleMotionsLayout.toml index 81aff423..edfe6798 100644 --- a/src/test/integration/test-workspace/simpleMotionsLayout.toml +++ b/src/test/integration/test-workspace/simpleMotionsLayout.toml @@ -1,5 +1,5 @@ [header] -version = "2.0" +version = "2.0.0" [[mode]] name = "insert" diff --git a/src/test/integration/test-workspace/textDocExample.toml b/src/test/integration/test-workspace/textDocExample.toml index f20592a3..aaa80cfb 100644 --- a/src/test/integration/test-workspace/textDocExample.toml +++ b/src/test/integration/test-workspace/textDocExample.toml @@ -1,7 +1,7 @@ # # Test Documentation #- IGNORED COMMENT [header] -version = "2.0" +version = "2.0.0" [[mode]] name = "insert" diff --git a/src/test/integration/test-workspace/visualDocExample.toml b/src/test/integration/test-workspace/visualDocExample.toml index 15765d68..d555198a 100644 --- a/src/test/integration/test-workspace/visualDocExample.toml +++ b/src/test/integration/test-workspace/visualDocExample.toml @@ -1,7 +1,7 @@ # # Test Documentation #- IGNORED COMMENT [header] -version = "2.0" +version = "2.0.0" [[mode]] name = "insert" diff --git a/test.txt b/test.txt new file mode 100644 index 00000000..e69de29b From b92e685788cad8be27e85faa2c7aee6e80d144a8 Mon Sep 17 00:00:00 2001 From: David Little Date: Thu, 9 Oct 2025 23:08:01 -0400 Subject: [PATCH 68/79] prefix refactored Created using spr 1.3.6-beta.1 --- notes.md | 12 +- src/rust/parsing/src/bind.rs | 208 +++++++++++----------------- src/rust/parsing/src/bind/prefix.rs | 78 +++++++++++ src/rust/parsing/src/file.rs | 107 +++++++------- 4 files changed, 227 insertions(+), 178 deletions(-) create mode 100644 src/rust/parsing/src/bind/prefix.rs diff --git a/notes.md b/notes.md index 07258b46..9a024c66 100644 --- a/notes.md +++ b/notes.md @@ -236,18 +236,21 @@ Integration test debugging: - [X] debug error processing in `keybindings/index.ts` - [ ] BUG: prefides defined via `master-key.prefix` are not included in `all_prefixes` - - [ ] get rid of the `prefixes` field design and instead allow + - [X] get rid of the `prefixes` field design and instead allow a way to express "prefix is X" "prefix isn't X" etc... more directly. since this wouldn't be an expression it could be during a phase of file resolution that already knows about the available prefixes. Like this: ```toml prefix.anyOf = ["a", "b", "c"] - prefix.notAnyOf = ["x", "y"] + prefix.allBut = ["x", "y"] + prefix.any = true # defaults to - prefix.anyOf = [""] + prefix.any = false ``` - - [ ] validate that the excludes don't contain new prefixes + - [X] validate that the excludes don't contain new prefixes + - [ ] unit tests + - [ ] documentation - [ ] error handling checks - [ ] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression @@ -256,6 +259,7 @@ Integration test debugging: - [ ] make sure a range is always provided - [ ] test that all error messages show up when expected - [ ] review coverage to verify there aren't additional checks we're missing + - [ ] integration test for both warnings and errors in type script setup - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index fd0b2b53..8e17e1a5 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -16,11 +16,13 @@ use wasm_bindgen::prelude::*; pub mod command; pub mod foreach; +pub mod prefix; pub mod validation; use crate::bind::command::{Command, regularize_commands}; +use crate::bind::prefix::{Prefix, PrefixInput}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{ErrorContext, Result, ResultVec, err}; +use crate::error::{ErrorContext, Result, ResultVec, err, wrn}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; @@ -145,8 +147,7 @@ pub struct BindingInput { /// Note that if `prefixes` is an expression, it *cannot* produce a novel prefix /// not defined elsewhere. This is to avoid circular computation when /// resolving the return value of `all_prefixes`. - #[serde(default = "span_plural_default")] - pub prefixes: Spanned>>, + pub prefixes: Option>, /// @forBindingField bind /// @@ -247,79 +248,6 @@ impl BindingInput { doc: self.doc.clone(), }; } - - pub(crate) fn add_to_scope( - inputs: &Vec>, - scope: &mut Scope, - ) -> ResultVec<()> { - let mut all_prefixes = HashSet::new(); - for input in inputs { - if let TypedValue::Constant(prefixes) = input.as_ref().prefixes.as_ref() { - let explicit_prefixes: Vec = - prefixes.clone().resolve("prefixes", scope).unwrap(); - let span = input.span().clone(); - let key_sequence: String = input - .as_ref() - .key - .clone() - .resolve("key", scope) - .with_range(&span)?; - if explicit_prefixes.len() > 0 { - for p in explicit_prefixes { - let seq = WHITESPACE.split(&p).chain(WHITESPACE.split(&key_sequence)); - for s in list_prefixes(seq) { - all_prefixes.insert(s.join(" ")); - } - } - } else { - let seq = WHITESPACE.split(&key_sequence); - let prefixes = list_prefixes(seq); - for s in prefixes[0..(prefixes.len() - 1)].iter() { - all_prefixes.insert(s.join(" ")); - } - }; - } - } - - scope.prefixes = all_prefixes; - let all_prefixes_fn_data = scope.prefixes.clone(); - scope.engine.register_fn("all_prefixes", move || { - all_prefixes_fn_data - .iter() - .map(|x| rhai::Dynamic::from(ImmutableString::from(x))) - .collect::() - }); - - let not_prefixes_fn_data = scope.prefixes.clone(); - scope.engine.register_fn( - "not_prefixes", - move |x: rhai::Array| -> std::result::Result> { - let not_prefixes = x - .into_iter() - .map(|xi| xi.into_immutable_string()) - .collect::, _>>()?; - let mut result = rhai::Array::new(); - for prefix in ¬_prefixes_fn_data { - if not_prefixes.iter().all(|x| x != prefix) { - result.push(rhai::Dynamic::from(ImmutableString::from(prefix))); - } - } - if result.len() == (¬_prefixes_fn_data).len() { - let mut bad_prefix = None; - for prefix in not_prefixes { - if (¬_prefixes_fn_data).iter().all(|x| x != prefix) { - bad_prefix = Some(prefix); - break; - } - } - return Err(format!("prefix `{}` does not exist", bad_prefix.unwrap()).into()); - } - return Ok(result); - }, - ); - - return Ok(()); - } } impl Merging for BindingInput { @@ -407,7 +335,7 @@ impl Expanding for BindingInput { }), prefixes: self.prefixes.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, TypedValue::default()) + None }), finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -655,7 +583,6 @@ pub struct LegacyBindingInput { computedArgs: Option>, path: Option>, mode: Option>>, // to check for `!` prefixed mode names etc... - prefixes: Option>>, // to check for ``. name: Option>, description: Option>, kind: Option>, @@ -713,20 +640,6 @@ impl LegacyBindingInput { } } - if let Some(spanned) = &self.prefixes { - let span = spanned.span().clone(); - let Plural(prefixes) = spanned.as_ref().clone(); - if prefixes.iter().any(|s| s == "") { - let err: Result<()> = Err(wrn!( - "file format 2.0 does not support ``, use `{}` \ - instead", - "{{all_prefixes()}}" - )) - .with_range(&span); - errors.push(err.unwrap_err()) - } - } - if let Some(spanned) = &self.name { let err: Result<()> = Err(wrn!( "`name` no longer exists in the 2.0 format; replace \ @@ -823,7 +736,7 @@ pub struct Binding { pub when: Option, pub mode: Vec, pub priority: f64, - pub prefixes: Vec, + pub(crate) prefixes: Prefix, pub finalKey: bool, pub(crate) repeat: TypedValue, pub tags: Vec, @@ -923,26 +836,6 @@ impl Binding { .with_range(&mode_span)?; } - // prefix validation - let prefixes_span = input.prefixes.span().clone(); - let prefixes: Vec = input.prefixes.clone().resolve("prefixes", scope)?; - let non_static_prefixes: Vec<_> = prefixes - .iter() - .filter(|x| !scope.prefixes.contains(x.as_str())) - .collect(); - if non_static_prefixes.len() > 0 { - return Err(err!( - "Prefixes must be statically defined, but some prefixes \ - were only defined within expression blocks: `{}`", - non_static_prefixes - .iter() - .map(|x| x.as_str()) - .collect::>() - .join("`, `") - )) - .with_range(&prefixes_span)?; - } - // require that bare keybindings (those without a modifier key) // be specific to `textEditorFocus` / `keybindingPaletteOpen` context let key_string: String = resolve!(input, key, scope)?; @@ -978,6 +871,66 @@ impl Binding { return Ok(result); } + + pub(crate) fn resolve_prefixes( + mut binds: Vec, + spans: &Vec>, + ) -> ResultVec> { + let mut all_prefixes = HashSet::new(); + let empty_vec = vec![]; + for bind in &binds { + let explicit_prefixes = match &bind.prefixes { + Prefix::Any(false) => &empty_vec, + Prefix::AnyOf(x) => x, + _ => continue, // these types don't define new prefixes, they reference what already exists + }; + if explicit_prefixes.len() > 0 { + for p in explicit_prefixes { + let seq = WHITESPACE + .split(&p) + .chain(bind.key.iter().map(String::as_str)); + for s in list_prefixes(seq) { + all_prefixes.insert(s.join(" ")); + } + } + } else { + let prefixes = list_prefixes(bind.key.iter().map(String::as_str)); + for s in prefixes[0..(prefixes.len() - 1)].iter() { + all_prefixes.insert(s.join(" ")); + } + }; + } + + let mut errors = Vec::new(); + for (bind, span) in binds.iter_mut().zip(spans.iter()) { + bind.prefixes = match &bind.prefixes { + Prefix::Any(true) => Prefix::AnyOf(all_prefixes.iter().map(String::from).collect()), + Prefix::Any(false) => Prefix::AnyOf(vec!["".to_string()]), + Prefix::AllBut(x) => { + let x_set: HashSet<_> = x.iter().map(String::from).collect(); + let selected = all_prefixes.difference(&x_set); + let undefined = x_set.difference(&all_prefixes); + let undefined_str = undefined + .map(|x| format!("`{x}`")) + .collect::>() + .join(", "); + if undefined_str.len() > 0 { + let error: Result<()> = + Err(err!("Prefix(es) undefined: {undefined_str}")).with_range(span); + + errors.push(error.unwrap_err()); + } + Prefix::AnyOf(selected.map(|x| x.to_owned()).collect()) + } + other @ _ => other.clone(), + } + } + if errors.len() > 0 { + return Err(errors.into()); + } else { + return Ok(binds); + } + } } // // ---------------- `bind.doc` object ---------------- @@ -1313,10 +1266,9 @@ impl Binding { if mode != &scope.default_mode { when_with_mode.push(format!("master-key.mode == '{mode}'")); } - let prefixes = if self.prefixes.is_empty() { - vec!["".to_string()] - } else { - self.prefixes.clone() + let prefixes = match &self.prefixes { + Prefix::AnyOf(x) => x, + x @ _ => panic!("Unexpected, unresolved prefix: {x:?}"), }; // ...and a distinct binding for each `self.prefix` for prefix in prefixes { @@ -1461,7 +1413,7 @@ mod tests { priority = 1 default = "{{bind.foo_bar}}" foreach.index = [1,2,3] - prefixes = "c" + prefixes.anyOf = "c" finalKey = true repeat = "{{2+c}}" tags = ["foo", "bar"] @@ -1513,8 +1465,12 @@ mod tests { ); assert_eq!(when, "joe > 1".to_string()); - let prefixes: Vec = resolve!(result, prefixes, &mut scope).unwrap(); - assert_eq!(prefixes, ["c"]); + let prefixes: Prefix = resolve!(result, prefixes, &mut scope).unwrap(); + let prefix_strs = match prefixes { + Prefix::AnyOf(x) => x, + _ => panic!("unexpected"), + }; + assert_eq!(prefix_strs, ["c"]); let finalKey: bool = resolve!(result, finalKey, &mut scope).unwrap(); assert_eq!(finalKey, true); @@ -1577,13 +1533,13 @@ mod tests { [[bind]] doc.name = "default" command = "cursorMove" - prefixes = ["a"] + prefixes.anyOf = ["a"] [[bind]] key = "l" doc.name = "←" args.to = "left" - prefixes = ["b", "c"] + prefixes.anyOf = ["b", "c"] "#; let result = toml::from_str::>>(data).unwrap(); @@ -1604,8 +1560,12 @@ mod tests { Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) ); - let prefixes: Vec = resolve!(left, prefixes, &mut scope).unwrap(); - assert_eq!(prefixes, ["b".to_string(), "c".to_string()]); + let prefixes: Prefix = resolve!(left, prefixes, &mut scope).unwrap(); + let prefix_strs = match prefixes { + Prefix::AnyOf(x) => x, + _ => panic!("unexpected"), + }; + assert_eq!(prefix_strs, ["b".to_string(), "c".to_string()]); let doc = left.doc.unwrap(); let combined: Option = resolve!(doc, combined, &mut scope).unwrap(); diff --git a/src/rust/parsing/src/bind/prefix.rs b/src/rust/parsing/src/bind/prefix.rs new file mode 100644 index 00000000..b37ba5d4 --- /dev/null +++ b/src/rust/parsing/src/bind/prefix.rs @@ -0,0 +1,78 @@ +use crate::error::{Result, ResultVec}; +use crate::expression::Scope; +use crate::expression::value::{Expanding, Expression, TypedValue, Value}; +use crate::util::{LeafValue, Merging, Plural, Resolving}; + +use serde::{Deserialize, Serialize}; +use wasm_bindgen::prelude::*; + +// TODO: we could improve error messages here by implementing Deserialize ourselves +#[derive(Deserialize, Clone, Debug)] +#[serde(rename_all = "camelCase")] +pub enum PrefixInput { + AnyOf(Plural>), + AllBut(Plural>), + Any(TypedValue), +} + +impl Default for PrefixInput { + fn default() -> Self { + return PrefixInput::Any(TypedValue::Constant(false)); + } +} + +#[derive(Serialize, Clone, Debug)] +pub enum Prefix { + AnyOf(Vec), + AllBut(Vec), + Any(bool), +} + +impl Default for Prefix { + fn default() -> Self { + return Prefix::Any(false); + } +} + +impl LeafValue for Prefix {} + +impl Resolving for PrefixInput { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec { + return match self { + PrefixInput::AnyOf(pl) => Ok(Prefix::AnyOf(pl.resolve(name, scope)?)), + PrefixInput::AllBut(pl) => Ok(Prefix::AllBut(pl.resolve(name, scope)?)), + PrefixInput::Any(f) => Ok(Prefix::Any(f.resolve(name, scope)?)), + }; + } +} + +impl Expanding for PrefixInput { + fn is_constant(&self) -> bool { + return match self { + PrefixInput::AnyOf(x) => x.is_constant(), + PrefixInput::AllBut(x) => x.is_constant(), + PrefixInput::Any(x) => x.is_constant(), + }; + } + + fn map_expressions(self, f: &mut F) -> ResultVec + where + Self: Sized, + F: FnMut(Expression) -> Result, + { + return match self { + PrefixInput::AnyOf(x) => Ok(PrefixInput::AnyOf(x.map_expressions(f)?)), + PrefixInput::AllBut(x) => Ok(PrefixInput::AllBut(x.map_expressions(f)?)), + PrefixInput::Any(x) => Ok(PrefixInput::Any(x.map_expressions(f)?)), + }; + } +} + +impl Merging for PrefixInput { + fn coalesce(self, new: Self) -> Self { + return new; + } + fn merge(self, new: Self) -> Self { + return new; + } +} diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 21783836..6796fb89 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -220,12 +220,11 @@ impl KeyFile { }; define.add_to_scope(&mut scope)?; - BindingInput::add_to_scope(&bind_input, &mut scope)?; let _ = scope .parse_asts(&bind_input) .map_err(|mut es| errors.append(&mut es.errors)); - let bind_and_span: Vec<_> = bind_input + let (mut bind, bind_span): (Vec<_>, Vec<_>) = bind_input .into_iter() .flat_map(|x| { let span = x.span().clone(); @@ -258,15 +257,15 @@ impl KeyFile { } } }) - .collect(); + .unzip(); + bind = Binding::resolve_prefixes(bind, &bind_span)?; // TODO: store spans so we can do avoid serializing this data?? let mut key_bind = Vec::new(); - let mut bind = Vec::new(); let mut codes = BindingCodes::new(); - for (i, (bind_item, span)) in bind_and_span.into_iter().enumerate() { + // TODO: call `resolve_prefixes` first + for (i, (bind_item, span)) in bind.iter_mut().zip(bind_span.into_iter()).enumerate() { key_bind.append(&mut bind_item.outputs(i as i32, &scope, span, &mut codes)?); - bind.push(bind_item); } key_bind.sort_by(BindingOutput::cmp_priority); // remove key_bind values with the exact same `key_id`, keeping the one @@ -443,6 +442,7 @@ mod tests { use super::*; use crate::bind::BindingOutputArgs; use crate::bind::UNKNOWN_RANGE; + use crate::bind::prefix::Prefix; use crate::expression::value::Expression; use crate::expression::value::Value; use smallvec::SmallVec; @@ -896,6 +896,13 @@ mod tests { assert_eq!(report[0].range.start.line, 17) } + fn unwrap_prefixes(prefix: &Prefix) -> &Vec { + return match prefix { + Prefix::AnyOf(x) => x, + x @ _ => panic!("Unexpected, unresolved prefix: {x:?}"), + }; + } + #[test] fn eval_prefix_expressions() { let data = r#" @@ -913,26 +920,54 @@ mod tests { [[bind]] key = "z" command = "biz" - prefixes = '{{all_prefixes()}}' + prefixes.any = true [[bind]] key = "w" command = "baz" - prefixes = '{{not_prefixes(["d e"])}}' + prefixes.allBut = ["d e"] "#; let mut scope = Scope::new(); let result = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); - assert!(result.bind[2].prefixes.iter().any(|x| x == "a")); - assert!(result.bind[2].prefixes.iter().any(|x| x == "a b")); - assert!(result.bind[2].prefixes.iter().any(|x| x == "d")); - assert!(result.bind[2].prefixes.iter().any(|x| x == "d e")); - assert_eq!(result.bind[2].prefixes.len(), 4); - assert!(result.bind[3].prefixes.iter().any(|x| x == "a")); - assert!(result.bind[3].prefixes.iter().any(|x| x == "a b")); - assert!(result.bind[3].prefixes.iter().any(|x| x == "d")); - assert_eq!(result.bind[3].prefixes.len(), 3); + assert!( + unwrap_prefixes(&result.bind[2].prefixes) + .iter() + .any(|x| x == "a") + ); + assert!( + unwrap_prefixes(&result.bind[2].prefixes) + .iter() + .any(|x| x == "a b") + ); + assert!( + unwrap_prefixes(&result.bind[2].prefixes) + .iter() + .any(|x| x == "d") + ); + assert!( + unwrap_prefixes(&result.bind[2].prefixes) + .iter() + .any(|x| x == "d e") + ); + assert_eq!(unwrap_prefixes(&result.bind[2].prefixes).len(), 4); + assert!( + unwrap_prefixes(&result.bind[3].prefixes) + .iter() + .any(|x| x == "a") + ); + assert!( + unwrap_prefixes(&result.bind[3].prefixes) + .iter() + .any(|x| x == "a b") + ); + assert!( + unwrap_prefixes(&result.bind[3].prefixes) + .iter() + .any(|x| x == "d") + ); + assert_eq!(unwrap_prefixes(&result.bind[3].prefixes).len(), 3); } #[test] @@ -952,43 +987,16 @@ mod tests { [[bind]] key = "w" command = "baz" - prefixes = '{{not_prefixes(["d k"])}}' + prefixes.allBut = ["d k"] "#; let mut scope = Scope::new(); let err = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); let report = err.report(data.as_bytes()); - assert!(report[0].message.contains("prefix `d k`")); - assert_eq!(report[0].range.start.line, 15) - } - - #[test] - fn validate_prefixes_are_static() { - let data = r#" - [header] - version = "2.0.0" - - [[bind]] - key = "a b c" - command = "foo" - - [[bind]] - key = "d e f" - command = "bar" - - [[bind]] - key = "w" - command = "baz" - prefixes = '{{["d e", "g h"]}}' - "#; + assert!(report[0].message.contains("undefined: `d k`")); - let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); - let report = err.report(data.as_bytes()); - assert!(report[0].message.contains("statically defined")); - assert_eq!(report[0].range.start.line, 15) + assert_eq!(report[0].range.start.line, 12) } #[test] @@ -1207,7 +1215,7 @@ mod tests { [[bind]] key = "a b" command = "foo" - prefixes = ["x y", "h k"] + prefixes.anyOf = ["x y", "h k"] "#; let mut scope = Scope::new(); @@ -1242,11 +1250,10 @@ mod tests { command = "master-key.enterNormal" computedArgs = "a+1" when = "!findWidgetVisible" - prefixes = "" "#; let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); - assert_eq!(warnings.errors.len(), 13); + assert_eq!(warnings.errors.len(), 12); } #[test] From ac4c767f58de42e752b1e5c5fff100b7304f8d74 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 10 Oct 2025 22:52:48 -0400 Subject: [PATCH 69/79] fix prefix unit tests, update docs Created using spr 1.3.6-beta.1 --- notes.md | 9 ++- src/extension/commands/prefix.ts | 22 ++++---- src/rust/parsing/src/bind.rs | 83 ++++++++++++++-------------- src/rust/parsing/src/bind/foreach.rs | 2 +- src/rust/parsing/src/expression.rs | 6 -- src/rust/parsing/src/file.rs | 29 ++++++++-- 6 files changed, 81 insertions(+), 70 deletions(-) diff --git a/notes.md b/notes.md index 9a024c66..f2c0e526 100644 --- a/notes.md +++ b/notes.md @@ -234,7 +234,7 @@ Integration test debugging: - [X] implement `[header]` section - [X] instead of using `.mk.toml`, look for a specific heading comment in the file - [X] debug error processing in `keybindings/index.ts` - - [ ] BUG: prefides defined via `master-key.prefix` are not included in + - [X] BUG: prefides defined via `master-key.prefix` are not included in `all_prefixes` - [X] get rid of the `prefixes` field design and instead allow a way to express "prefix is X" "prefix isn't X" etc... @@ -249,8 +249,11 @@ Integration test debugging: prefix.any = false ``` - [X] validate that the excludes don't contain new prefixes - - [ ] unit tests - - [ ] documentation + - [X] unit tests + - [X] handle `master-key.prefix` (in this case we need to include + the last key as a valid prefix) + - [X] unit tests + - [X] documentation - [ ] error handling checks - [ ] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression diff --git a/src/extension/commands/prefix.ts b/src/extension/commands/prefix.ts index 223cc6ed..ee9832cc 100644 --- a/src/extension/commands/prefix.ts +++ b/src/extension/commands/prefix.ts @@ -79,7 +79,7 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * ``` * * These prefixes may be explicitly specified in this way so they can be documented. When - * users do not provide an explicit prefix, Master key explicitly creates these bindings by + * users do not provide an explicit prefix, Master key implicitly creates these bindings by * itself, but without documentation. As such, all of the bindings written in a * `keybinding.json` file have just a single key press, with some conditioned on the * specific prefix that must occur beforehand. This is so that master key can explicitly @@ -87,7 +87,7 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * * ## Prefix Format * - * The prefix state is stored under `prefix` (when evaluating an + * The prefix state is stored under `key.prefix` (when evaluating an * [expression](/expressions/index)) and under `master-key.prefix` in a `when` clause * (though it should rarely be necessary to access the prefix explicitly in a `when` * clause). It is stored as a space delimited sequence of keybindings in the same form that @@ -98,7 +98,7 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * * A binding that includes a `prefix` command has `finalKey` set to `false`. Whereas, * without a `prefix` command present, the default is `true`. When `finalKey` is `false` - * master key not reset any previously set transient state (e.g. from previous calls to + * master key does not reset any previously set transient state (e.g. from previous calls to * `prefix` or transient [`setFlag`](/commands/setFlag)). When `finalKey` is `true` any * transient state is returned to a default, unset state. * @@ -111,12 +111,12 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * ```toml * [[bind]] * key = "shift+;" - * name = "suggest" + * doc.name = "suggest" * finalKey = false - * hideInPalette = true - * prefixes = "{{all_prefixes}}" - * mode = ["!capture", "!insert"] - * description = """ + * doc.hideInPalette = true + * prefixes.any = true + * mode = '{{not_modes(["capture", "insert"])}}' + * doc.description = """ * show command suggestions within the context of the current mode and keybinding prefix * (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions * that start with `TAB`. @@ -126,8 +126,7 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * * A few things are going on here: * - * 1. The binding applies regardless of the current prefix (`prefixes = - * "{{all_prefixes}}"). + * 1. The binding applies regardless of the current prefix (`prefixes.any = true`). * 2. This calls a command that lists possible keys that can be pressed given the current * prefix (`command = "master-key.commandSuggestions"`). `master-key.prefix` is not * called, so the press of `shift+;` will not update to the current sequence of keys that @@ -136,7 +135,8 @@ export function prefixCodes(state: CommandState): [CommandState, PrefixCodes] { * will continue to wait for additional key presses that can occur for the given * keybinding prefix. * - * In this way the user can ask for help regarding which keys they can press next. + * In this way the user can ask for help regarding which keys they can press next, + * without resetting the state. */ let oldPrefixCursor: boolean = false; diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 8e17e1a5..1f3454e3 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -136,26 +136,24 @@ pub struct BindingInput { /// @forBindingField bind /// - /// - `prefixes`: string, array of strings or an expression producing such a value (e.g. - /// [`all_prefixes`](expressions/functions#all_prefixes)). The prefixes determine one - /// or more *unresolved* key sequences that can have been pressed before typing this - /// key binding. See [`master-key.prefix`](/commands/prefix) for details. Defaults to - /// an empty array, which indicates that no prior keys can have been pressed. Setting - /// this to '{{all_prefixes()}}', will allow a key binding to work - /// regardless of any unresolved key sequence that has been pressed: this is how `esc` - /// is defined to work in Larkin. (See also [`not_prefixes(...)`](/expressions/index)). - /// Note that if `prefixes` is an expression, it *cannot* produce a novel prefix - /// not defined elsewhere. This is to avoid circular computation when - /// resolving the return value of `all_prefixes`. + /// - `prefixes`: expresses the allowed key sequences that occur *before* this + /// keybinding using a call to [`master-key.prefix`](/commands/prefix). This is an object + /// with one of three possible keys: + /// - `any`: when `true` any prefix is allowed before the binding, `false` + /// means no sequence can occur prior to this binding (this is the default behavior). + /// - `anyOf`: A single string or an array of strings, each an allowed prefix + /// - `allBut`: A single string or an array of strings; all prefixes *except* + /// those specified here are valid pub prefixes: Option>, /// @forBindingField bind /// - /// - `finalKey`: (boolean, default=true) Whether this key should clear any transient - /// state associated with the pending keybinding prefix. See - /// [`master-key.prefix`](/commands/prefix) for details. - #[serde(default = "spanned_value_true")] - pub finalKey: Spanned>, + /// - `finalKey`: (boolean, default=true unless `master-key.prefix` is a command) + /// Whether this key should clear any transient state associated with the pending + /// keybinding prefix. See [`master-key.prefix`](/commands/prefix) for details. When + /// `master-key.prefix` is one of the commands in this binding, this field defaults to + /// `false`. + pub finalKey: Option>>, /// @forBindingField bind /// @@ -339,7 +337,7 @@ impl Expanding for BindingInput { }), finalKey: self.finalKey.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - spanned_value_true() + None }), repeat: self.repeat.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -807,8 +805,9 @@ impl Binding { // finalKey validation let has_prefix = commands.iter().any(|c| c.command == "master-key.prefix"); + let final_key_result: Option = resolve!(input, finalKey, scope)?; #[allow(non_snake_case)] - let finalKey: bool = resolve!(input, finalKey, scope)?; + let finalKey = final_key_result.unwrap_or(!has_prefix); if has_prefix && finalKey { return Err(err( "`finalKey` must be `false` when `master-key.prefix` is run", @@ -895,7 +894,16 @@ impl Binding { } } else { let prefixes = list_prefixes(bind.key.iter().map(String::as_str)); - for s in prefixes[0..(prefixes.len() - 1)].iter() { + let offset = if bind + .commands + .iter() + .any(|c| c.command == "master-key.prefix") + { + 0 + } else { + 1 + }; + for s in prefixes[0..(prefixes.len() - offset)].iter() { all_prefixes.insert(s.join(" ")); } }; @@ -1230,20 +1238,6 @@ pub(crate) fn list_prefixes(seq: impl Iterator) -> Vec{{keys([quoted-regex])}} is included /// in a `foreach` value, it is expanded to all keybindings that match the given regular /// expression and spliced into the array of values. For example, the following definition -/// is used in `Larkin` to allow the numeric keys to be used as count prefix for motions. +/// is used in `Larkin` to allow the numeric keys to be used as a count prefix for motions. /// /// ```toml /// [[bind]] diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 865e3545..d63ff6b7 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -77,10 +77,6 @@ use crate::{ /// - Variables defined by [`foreach`](/bindings/bind#foreach-clauses) /// - `keys([regex]):` returns all keys matching the regular expression defined by the given /// string -/// - `all_prefixes()`: returns an array of strings of all keybinding prefixes defined by -/// the current set of keybindigs -/// - `not_prefixes([exclusions])`: given an array of strings of prefixes not to use, -/// returns all prefixes defined by the current set of keybindings. /// - `all_modes()`: returns an array of strings all keybinding modes defined by the current /// keybinding set /// - `not_modes([exclusions])`: given an array of strings of excluded modes, returns @@ -118,7 +114,6 @@ use crate::{ pub struct Scope { pub(crate) asts: HashMap, pub(crate) engine: rhai::Engine, - pub(crate) prefixes: HashSet, pub(crate) modes: HashSet, pub(crate) kinds: HashSet, pub(crate) default_mode: String, @@ -187,7 +182,6 @@ impl Scope { engine: engine, state: rhai::Scope::new(), default_mode: "default".to_string(), - prefixes: HashSet::from(["".to_string()]), modes: HashSet::from(["default".to_string()]), kinds: HashSet::new(), queues: HashMap::new(), diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 6796fb89..03d93a43 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -101,21 +101,22 @@ /// - `bind.path` and `[[path]]`: A similar, but more explicit approach /// is possible using `default` and [`define.bind`](/bindings/define#binding-definitions) /// - replaced `mode = []` with `mode = '{{all_modes()}}'` -/// - replaced "<all-prefixes>" with `'{{all_prefixes()}}'` **TODO** /// - replaced `mode = ["!insert", "!capture"]` with /// `mode = '{{not_modes(["insert", "capture"])}}'` -/// - renamed several fields: +/// - revised several fields: +/// - replaced `prefixes = ["a", "b", ...]` with `prefixes.anyOf = ["a", "b", ...]` +/// - replaced prefixes = "<all-prefixes>" with `prefixes.any = true` /// - `name`, `description`, `hideInPalette` and `hideInDocs` moved to /// `doc.name`, `doc.description`, `doc.hideInPalette` and `doc.hideInDocs` /// - `combinedName`, `combinedDescription` and `combinedKey` moved to /// `doc.combined.name`, `doc.combined.description` and `doc.combined.key`. /// - `resetTransient` is now [`finalKey`](/bindings/bind) -/// - `bind.if` is renamed to [`bind.skipWhen`](/bindings/bind) +/// - `bind.if` replaced with [`bind.skipWhen`](/bindings/bind) /// - `name` renamed to `register` in [`(re)storeNamed`](/commands/storeNamed) command /// - Rename replay-related command fields: /// - `at` to `whereIndexIs` /// - `range` to `whereRangeIs` -/// - the variable `i` renamed to `index` +/// - the variable `i` renamed to `index` in expressions of these fields #[allow(unused_imports)] use log::{error, info}; @@ -926,6 +927,11 @@ mod tests { key = "w" command = "baz" prefixes.allBut = ["d e"] + + [[bind]] + key = "q" + command = "master-key.prefix" + finalKey = false "#; let mut scope = Scope::new(); @@ -951,7 +957,12 @@ mod tests { .iter() .any(|x| x == "d e") ); - assert_eq!(unwrap_prefixes(&result.bind[2].prefixes).len(), 4); + assert!( + unwrap_prefixes(&result.bind[2].prefixes) + .iter() + .any(|x| x == "q") + ); + assert_eq!(unwrap_prefixes(&result.bind[2].prefixes).len(), 5); assert!( unwrap_prefixes(&result.bind[3].prefixes) .iter() @@ -967,7 +978,12 @@ mod tests { .iter() .any(|x| x == "d") ); - assert_eq!(unwrap_prefixes(&result.bind[3].prefixes).len(), 3); + assert!( + unwrap_prefixes(&result.bind[3].prefixes) + .iter() + .any(|x| x == "q") + ); + assert_eq!(unwrap_prefixes(&result.bind[3].prefixes).len(), 4); } #[test] @@ -1063,6 +1079,7 @@ mod tests { [[bind]] key = "x" command = "runCommands" + finalKey = true [[bind.args.commands]] command = "x" From d50e51fb89af239ab8dcf48f00018a151a8bc322 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 11 Oct 2025 20:12:33 -0400 Subject: [PATCH 70/79] remove incorrect line positions from rhai script error messages Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/error.rs | 10 +++++++++- src/rust/parsing/src/expression.rs | 13 +++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 630e6e46..9e2f4b8f 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -2,6 +2,8 @@ use log::info; use core::ops::Range; +use lazy_static::lazy_static; +use regex::Regex; use rhai::{self, EvalAltResult}; use serde::Serialize; use smallvec::SmallVec; @@ -353,6 +355,10 @@ fn resolve_rhai_pos_from_expression_range( return char_line_range; } +lazy_static! { + static ref LINE_MESSAGE: Regex = Regex::new(r"\(line [0-9]+, position [0-9]+\)").unwrap(); +} + #[wasm_bindgen] impl ParseError { /// `report` is how we generate legible annotations @@ -371,7 +377,9 @@ impl ParseError { } RawError::ExpressionParsing(rhai) => { rhai_pos = Some(rhai.position()); - message_buf.push_str(&self.error.to_string()); + let raw_msg = self.error.to_string(); + let msg = LINE_MESSAGE.replace_all(&raw_msg, ""); + message_buf.push_str(&msg); } _ => message_buf.push_str(&self.error.to_string()), }; diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index d63ff6b7..0c1797d7 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -346,4 +346,17 @@ mod tests { assert_eq!(r#"{{joe.bob.{{bill bob"#, val); assert!(message.contains("unexpected `")); } + + #[test] + fn clean_expression_error_locations() { + let data = r#" + bob = "{{x # y}}" + "#; + + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(!report[0].message.contains("(line")) + } } From 0d9059f3c16563841c2db86af0bd61d08a327651 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 11 Oct 2025 20:14:53 -0400 Subject: [PATCH 71/79] add additional legacy warning checks Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/file.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 03d93a43..a394a2c3 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1251,6 +1251,11 @@ mod tests { id = "modes" description = "foo bar" + [[bind]] + key = "a" + command = "foo" + mode = ["!capture"] + [[bind]] path = "modes" name = "normal" @@ -1262,6 +1267,7 @@ mod tests { combinedDescription = "all the things" key = "{key}" mode = [] + resetTransient = false hideInPalette = true hideInDocs = false command = "master-key.enterNormal" @@ -1270,7 +1276,7 @@ mod tests { "#; let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); - assert_eq!(warnings.errors.len(), 12); + assert_eq!(warnings.errors.len(), 14); } #[test] From 177fb4d3e30bb1044410d48eff8797b671813250 Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 11 Oct 2025 20:16:30 -0400 Subject: [PATCH 72/79] rename constant Created using spr 1.3.6-beta.1 --- src/rust/parsing/src/bind.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 1f3454e3..2933c65f 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -42,10 +42,6 @@ where return Spanned::new(UNKNOWN_RANGE, TypedValue::default()); } -fn spanned_value_true() -> Spanned> { - return Spanned::new(UNKNOWN_RANGE, TypedValue::Constant(true)); -} - // // ================ `[[bind]]` parsing ================ // @@ -741,7 +737,7 @@ pub struct Binding { pub doc: BindingDoc, } -const BARE_KEY_CONTEXT: &str = "(editorTextFocus || master-key.keybindingPaletteOpen \ +const TEXT_FOCUS_CONDITION: &str = "(editorTextFocus || master-key.keybindingPaletteOpen \ && master-key.keybindingPaletteBindingMode)"; lazy_static! { @@ -842,14 +838,14 @@ impl Binding { let mut when: Option = resolve!(input, when, scope)?; when = if !NON_BARE_KEY.is_match(&key[0]) { if let Some(w) = when { - Some(format!("({}) && {BARE_KEY_CONTEXT}", w)) + Some(format!("({}) && {TEXT_FOCUS_CONDITION}", w)) } else { - Some(BARE_KEY_CONTEXT.to_string()) + Some(TEXT_FOCUS_CONDITION.to_string()) } } else { Some( EDITOR_TEXT_FOCUS - .replace_all(&(when.unwrap()), BARE_KEY_CONTEXT) + .replace_all(&(when.unwrap()), TEXT_FOCUS_CONDITION) .to_string(), ) }; From da9bbd06a3279123e912f33f51d072436c99bbee Mon Sep 17 00:00:00 2001 From: David Little Date: Mon, 13 Oct 2025 16:59:04 -0400 Subject: [PATCH 73/79] wip: error checking improvements Created using spr 1.3.6-beta.1 --- .gitignore | 2 + notes.md | 40 +- src/rust/parsing/coverage/parsing.info | 4515 -------------------- src/rust/parsing/coverage/parsing.profdata | Bin 1288744 -> 0 bytes src/rust/parsing/src/bind.rs | 32 +- src/rust/parsing/src/bind/command.rs | 133 +- src/rust/parsing/src/bind/foreach.rs | 4 +- src/rust/parsing/src/define.rs | 22 +- src/rust/parsing/src/error.rs | 50 +- src/rust/parsing/src/expression.rs | 45 +- src/rust/parsing/src/expression/value.rs | 104 +- src/rust/parsing/src/file.rs | 72 +- src/rust/parsing/src/util.rs | 45 +- 13 files changed, 405 insertions(+), 4659 deletions(-) delete mode 100644 src/rust/parsing/coverage/parsing.info delete mode 100644 src/rust/parsing/coverage/parsing.profdata diff --git a/.gitignore b/.gitignore index b66b4285..cbe2c393 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,8 @@ node_modules # code coverage .nyc_output/** +*.info +*.profdata coverage/** coverage.json *.profraw diff --git a/notes.md b/notes.md index f2c0e526..be4e4229 100644 --- a/notes.md +++ b/notes.md @@ -255,13 +255,47 @@ Integration test debugging: - [X] unit tests - [X] documentation - [ ] error handling checks - - [ ] remove spurious line/char positions from expression error messages + - [X] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression which has nothing to do with the line and char position in the parent keybinding file - - [ ] make sure a range is always provided - - [ ] test that all error messages show up when expected + - [ ] list of errors to check on + - [X] parsing a number that's too large + - [X] duplicate toml key + - [X] unmatched `{{` when there are other matches braces before it + - [X] expression error for expression in an array + - [X] unmatched `{{` when child of array + - [X] unresolved expression (and interpolation) in conversion of Value -> BareValue + - [ ] warn about unexpected fields in `[[bind]]` (and others) + - [ ] invalid regex for `keys` function + - [ ] invalid keybinding strings (modifier and key) + - [ ] layout invariant binding works + - [ ] expression evaluating to non-string value for `key` fieldd + - [ ] unresolved expressions when converting from Value -> toml::Value + - [ ] errors in an expression of a `[[bind]]` field point to the field + - [ ] for top-level + - [ ] for docs + - [ ] for combined docs + - [ ] id field is reserved + - [ ] foreach with unresolved variables + - [ ] error in expression of `define.val/command/bind` + - [ ] allow expression interpolations to be keybindings + - [ ] an expression that isn't `{{bind.[id]}}` for a `default` field + - [ ] undefined `{{bind.[id]}}` reference in `default` field + - [ ] misplaced reference to `{{bind.[id]}}` + - [ ] TOML parsing errors + - [ ] error for use of legacy expression () + - [ ] unique kind names + - [ ] args set to non-table value when `command = "runCommands"` + - [ ] `args.commands` being a non-array value when `command = "runCommands"` + - [ ] non string value for `command` inside of `args.commands` + - [ ] `skipWhen` present for `command = "runCommands"` for an element + of `args.commands`. + - [ ] args is a non array or table value for a sub command of `runCommands` + - [ ] non table or string value for an array element of `runCommands` - [ ] review coverage to verify there aren't additional checks we're missing + - [ ] test that all error messages show up when expected + - [ ] make sure a range is always provided - [ ] integration test for both warnings and errors in type script setup - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command diff --git a/src/rust/parsing/coverage/parsing.info b/src/rust/parsing/coverage/parsing.info deleted file mode 100644 index d7dbd285..00000000 --- a/src/rust/parsing/coverage/parsing.info +++ /dev/null @@ -1,4515 +0,0 @@ -SF:src/rust/parsing/src/bind.rs -FN:577,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding6repeat -FN:419,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging8coalesce -FN:435,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging8coalesce -FN:235,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging8coalesce -FN:25,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultINtNtNtB4_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB4_ -FN:25,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultNtNtB2_10validation10KeyBindingEB4_ -FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsBz_E0EB8_ -FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBz_EEE0EB8_ -FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachBz_14expand_foreach00EB8_ -FN:278,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1P_6Define6expand0EB8_ -FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ -FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsNtB6_12BindingInputE0EB8_ -FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ -FN:457,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1S_6Define6expand0EB8_ -FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ -FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsNtB6_12BindingInputE0EB8_ -FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ -FN:505,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB20_6Define6expand0EB8_ -FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0E0Ba_ -FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es0_0Ba_ -FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es1_0Ba_ -FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es2_0Ba_ -FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es3_0Ba_ -FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es4_0Ba_ -FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es5_0Ba_ -FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es6_0Ba_ -FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es7_0Ba_ -FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es8_0Ba_ -FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es9_0Ba_ -FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es_0Ba_ -FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Esa_0Ba_ -FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0E0Ba_ -FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es0_0Ba_ -FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es1_0Ba_ -FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es2_0Ba_ -FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es3_0Ba_ -FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es4_0Ba_ -FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es5_0Ba_ -FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es6_0Ba_ -FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es7_0Ba_ -FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es8_0Ba_ -FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es9_0Ba_ -FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es_0Ba_ -FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Esa_0Ba_ -FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00E0Ba_ -FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es0_0Ba_ -FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es1_0Ba_ -FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es2_0Ba_ -FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es3_0Ba_ -FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es4_0Ba_ -FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es5_0Ba_ -FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es6_0Ba_ -FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es7_0Ba_ -FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es8_0Ba_ -FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es9_0Ba_ -FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es_0Ba_ -FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Esa_0Ba_ -FN:285,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0E0Ba_ -FN:293,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es0_0Ba_ -FN:297,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es1_0Ba_ -FN:301,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es2_0Ba_ -FN:305,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es3_0Ba_ -FN:309,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es4_0Ba_ -FN:313,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es5_0Ba_ -FN:317,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es6_0Ba_ -FN:321,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es7_0Ba_ -FN:325,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es8_0Ba_ -FN:329,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es9_0Ba_ -FN:289,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es_0Ba_ -FN:333,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Esa_0Ba_ -FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ -FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ -FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es1_0Ba_ -FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es2_0Ba_ -FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es3_0Ba_ -FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ -FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ -FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ -FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es1_0Ba_ -FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es2_0Ba_ -FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es3_0Ba_ -FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ -FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ -FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ -FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es1_0Ba_ -FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es2_0Ba_ -FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es3_0Ba_ -FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ -FN:464,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0E0Ba_ -FN:475,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es0_0Ba_ -FN:479,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es1_0Ba_ -FN:483,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es2_0Ba_ -FN:487,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es3_0Ba_ -FN:468,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es_0Ba_ -FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ -FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ -FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ -FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ -FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ -FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ -FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ -FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ -FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ -FN:512,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0E0Ba_ -FN:520,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es0_0Ba_ -FN:516,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es_0Ba_ -FN:640,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3new0B9_ -FN:647,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3news_0B9_ -FN:600,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding8commands0B9_ -FN:214,_RNvMNtCslo8MYDYmh8N_7parsing4bindNtB2_12BindingInput10without_id -FN:685,_RNvMs1b_NtCslo8MYDYmh8N_7parsing4bindNtB6_10BindingDoc3new -FN:699,_RNvMs1c_NtCslo8MYDYmh8N_7parsing4bindNtB6_18CombinedBindingDoc3new -FN:604,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding3new -FN:581,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding8commands -FN:29,_RNvNtCslo8MYDYmh8N_7parsing4bind19span_plural_default -FN:259,_RNvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB5_12BindingInputNtNtNtB7_10expression5value9Expanding11is_constant -FN:422,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging5merge -FN:439,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging5merge -FN:449,_RNvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant -FN:501,_RNvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant -FN:238,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging5merge -FN:534,_RNvXs5_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_15BindingDocInputEINtNtB7_4util9ResolvingNtB5_10BindingDocE7resolve -FN:543,_RNvXs6_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_23CombinedBindingDocInputEINtNtB7_4util9ResolvingIBz_NtB5_18CombinedBindingDocEE7resolve -FN:777,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_16complete_parsing0B7_ -FN:1013,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keys0B7_ -FN:1014,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keyss_0B7_ -FNDA:0,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding6repeat -FNDA:0,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging8coalesce -FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging8coalesce -FNDA:0,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging8coalesce -FNDA:6,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultINtNtNtB4_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB4_ -FNDA:11,_RINvNtCslo8MYDYmh8N_7parsing4bind21span_required_defaultNtNtB2_10validation10KeyBindingEB4_ -FNDA:3,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsBz_E0EB8_ -FNDA:10,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BW_NtBW_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBz_EEE0EB8_ -FNDA:34,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachBz_14expand_foreach00EB8_ -FNDA:13,_RINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB6_12BindingInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1P_6Define6expand0EB8_ -FNDA:4,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ -FNDA:3,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_BZ_NtBZ_5Scope10parse_astsNtB6_12BindingInputE0EB8_ -FNDA:34,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ -FNDA:5,_RINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB6_15BindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB1S_6Define6expand0EB8_ -FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_12BindingInputEEE0EB8_ -FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCINvMsf_B17_NtB17_5Scope10parse_astsNtB6_12BindingInputE0EB8_ -FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNCNvMNtB6_7foreachNtB6_12BindingInput14expand_foreach00EB8_ -FNDA:0,_RINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB6_23CombinedBindingDocInputNtNtNtB8_10expression5value9Expanding15map_expressionsNCNvMNtB8_6defineNtB20_6Define6expand0EB8_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0E0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es0_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es1_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es2_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es3_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es4_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es5_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es6_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es7_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es8_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es9_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Es_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsBB_E0Esa_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0E0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es0_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es1_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es2_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es3_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es4_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es5_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es6_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es7_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es8_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es9_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Es_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_BY_NtBY_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBB_EEE0Esa_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00E0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es0_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es1_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es2_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es3_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es4_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es5_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es6_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es7_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es8_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es9_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Es_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachBB_14expand_foreach00Esa_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0E0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es0_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es1_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es2_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es3_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es4_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es5_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es6_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es7_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es8_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es9_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Es_0Ba_ -FNDA:0,_RNCINvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB8_12BindingInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1R_6Define6expand0Esa_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es1_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es2_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es3_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es1_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es2_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es3_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B11_NtB11_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es1_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es2_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es3_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0E0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es0_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es1_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es2_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es3_0Ba_ -FNDA:0,_RNCINvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB8_15BindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB1U_6Define6expand0Es_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0E0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es0_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0Es_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0E0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es0_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B19_NtB19_5Scope10parse_astsNtB8_12BindingInputE0Es_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00E0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es0_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00Es_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0E0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es0_0Ba_ -FNDA:0,_RNCINvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB8_23CombinedBindingDocInputNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB22_6Define6expand0Es_0Ba_ -FNDA:22,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3new0B9_ -FNDA:1,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding3news_0B9_ -FNDA:10,_RNCNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB7_7Binding8commands0B9_ -FNDA:3,_RNvMNtCslo8MYDYmh8N_7parsing4bindNtB2_12BindingInput10without_id -FNDA:13,_RNvMs1b_NtCslo8MYDYmh8N_7parsing4bindNtB6_10BindingDoc3new -FNDA:1,_RNvMs1c_NtCslo8MYDYmh8N_7parsing4bindNtB6_18CombinedBindingDoc3new -FNDA:21,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding3new -FNDA:10,_RNvMsw_NtCslo8MYDYmh8N_7parsing4bindNtB5_7Binding8commands -FNDA:58,_RNvNtCslo8MYDYmh8N_7parsing4bind19span_plural_default -FNDA:3,_RNvXs0_NtCslo8MYDYmh8N_7parsing4bindNtB5_12BindingInputNtNtNtB7_10expression5value9Expanding11is_constant -FNDA:2,_RNvXs1_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtB7_4util7Merging5merge -FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtB7_4util7Merging5merge -FNDA:1,_RNvXs3_NtCslo8MYDYmh8N_7parsing4bindNtB5_15BindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant -FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4bindNtB5_23CombinedBindingDocInputNtNtNtB7_10expression5value9Expanding11is_constant -FNDA:6,_RNvXs_NtCslo8MYDYmh8N_7parsing4bindNtB4_12BindingInputNtNtB6_4util7Merging5merge -FNDA:19,_RNvXs5_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_15BindingDocInputEINtNtB7_4util9ResolvingNtB5_10BindingDocE7resolve -FNDA:15,_RNvXs6_NtCslo8MYDYmh8N_7parsing4bindINtNtCs7micvSKFzzu_4core6option6OptionNtB5_23CombinedBindingDocInputEINtNtB7_4util9ResolvingIBz_NtB5_18CombinedBindingDocEE7resolve -FNDA:3,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_16complete_parsing0B7_ -FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keys0B7_ -FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind5testss_19expand_foreach_keyss_0B7_ -FNF:50 -FNH:21 -DA:25,17 -DA:26,17 -DA:27,17 -DA:29,58 -DA:30,58 -DA:31,58 -DA:214,3 -DA:215,3 -DA:216,3 -DA:217,3 -DA:218,3 -DA:219,3 -DA:220,3 -DA:221,3 -DA:222,3 -DA:223,3 -DA:224,3 -DA:225,3 -DA:226,3 -DA:227,3 -DA:228,3 -DA:229,3 -DA:230,3 -DA:231,3 -DA:235,0 -DA:236,0 -DA:237,0 -DA:238,6 -DA:239,6 -DA:240,6 -DA:241,6 -DA:242,6 -DA:243,6 -DA:244,6 -DA:245,6 -DA:246,6 -DA:247,6 -DA:248,6 -DA:249,6 -DA:250,6 -DA:251,6 -DA:252,6 -DA:253,6 -DA:254,6 -DA:255,6 -DA:259,3 -DA:260,3 -DA:261,3 -DA:262,3 -DA:263,3 -DA:264,3 -DA:265,3 -DA:266,3 -DA:267,3 -DA:268,3 -DA:269,3 -DA:270,3 -DA:271,3 -DA:272,3 -DA:273,3 -DA:274,3 -DA:275,3 -DA:276,3 -DA:277,3 -DA:278,60 -DA:279,60 -DA:280,60 -DA:282,60 -DA:283,60 -DA:284,60 -DA:285,60 -DA:286,0 -DA:287,0 -DA:288,0 -DA:289,60 -DA:290,0 -DA:291,0 -DA:292,0 -DA:293,60 -DA:294,0 -DA:295,0 -DA:296,0 -DA:297,60 -DA:298,0 -DA:299,0 -DA:300,0 -DA:301,60 -DA:302,0 -DA:303,0 -DA:304,0 -DA:305,60 -DA:306,0 -DA:307,0 -DA:308,0 -DA:309,60 -DA:310,0 -DA:311,0 -DA:312,0 -DA:313,60 -DA:314,0 -DA:315,0 -DA:316,0 -DA:317,60 -DA:318,0 -DA:319,0 -DA:320,0 -DA:321,60 -DA:322,0 -DA:323,0 -DA:324,0 -DA:325,60 -DA:326,0 -DA:327,0 -DA:328,0 -DA:329,60 -DA:330,0 -DA:331,0 -DA:332,0 -DA:333,60 -DA:334,0 -DA:335,0 -DA:336,0 -DA:338,60 -DA:339,0 -DA:341,60 -DA:343,60 -DA:419,0 -DA:420,0 -DA:421,0 -DA:422,2 -DA:423,2 -DA:424,2 -DA:425,2 -DA:426,2 -DA:427,2 -DA:428,2 -DA:429,2 -DA:430,2 -DA:431,2 -DA:435,0 -DA:436,0 -DA:437,0 -DA:439,0 -DA:440,0 -DA:441,0 -DA:442,0 -DA:443,0 -DA:444,0 -DA:445,0 -DA:449,1 -DA:450,1 -DA:451,1 -DA:452,1 -DA:453,1 -DA:454,1 -DA:455,1 -DA:456,1 -DA:457,46 -DA:458,46 -DA:459,46 -DA:460,46 -DA:462,46 -DA:463,46 -DA:464,46 -DA:465,0 -DA:466,0 -DA:467,0 -DA:468,46 -DA:469,0 -DA:470,0 -DA:471,0 -DA:472,46 -DA:473,46 -DA:474,46 -DA:475,46 -DA:476,0 -DA:477,0 -DA:478,0 -DA:479,46 -DA:480,0 -DA:481,0 -DA:482,0 -DA:483,46 -DA:484,0 -DA:485,0 -DA:486,0 -DA:487,46 -DA:488,0 -DA:489,0 -DA:490,0 -DA:492,46 -DA:493,0 -DA:495,46 -DA:497,46 -DA:501,0 -DA:502,0 -DA:503,0 -DA:505,0 -DA:506,0 -DA:507,0 -DA:508,0 -DA:510,0 -DA:511,0 -DA:512,0 -DA:513,0 -DA:514,0 -DA:515,0 -DA:516,0 -DA:517,0 -DA:518,0 -DA:519,0 -DA:520,0 -DA:521,0 -DA:522,0 -DA:523,0 -DA:525,0 -DA:526,0 -DA:528,0 -DA:530,0 -DA:534,19 -DA:535,19 -DA:536,13 -DA:537,6 -DA:539,19 -DA:543,15 -DA:544,15 -DA:545,15 -DA:546,15 -DA:547,15 -DA:548,15 -DA:549,1 -DA:550,14 -DA:552,15 -DA:577,0 -DA:578,0 -DA:579,0 -DA:581,10 -DA:582,10 -DA:583,10 -DA:584,10 -DA:585,10 -DA:587,0 -DA:590,10 -DA:592,10 -DA:593,20 -DA:594,10 -DA:595,10 -DA:598,10 -DA:599,10 -DA:600,10 -DA:601,10 -DA:602,10 -DA:604,21 -DA:605,21 -DA:606,0 -DA:607,21 -DA:609,21 -DA:610,0 -DA:611,21 -DA:612,21 -DA:616,21 -DA:617,5 -DA:618,16 -DA:621,19 -DA:622,21 -DA:623,21 -DA:624,20 -DA:625,20 -DA:626,15 -DA:627,5 -DA:629,19 -DA:630,19 -DA:631,19 -DA:632,19 -DA:633,19 -DA:634,19 -DA:637,19 -DA:638,19 -DA:639,19 -DA:640,22 -DA:641,19 -DA:642,19 -DA:643,1 -DA:644,1 -DA:645,1 -DA:646,1 -DA:647,1 -DA:648,1 -DA:649,1 -DA:651,1 -DA:652,18 -DA:654,18 -DA:655,21 -DA:685,13 -DA:687,13 -DA:688,13 -DA:689,13 -DA:690,13 -DA:691,13 -DA:692,13 -DA:694,13 -DA:699,1 -DA:701,1 -DA:702,1 -DA:703,1 -DA:705,1 -DA:777,3 -DA:1013,9 -DA:1014,9 -BRF:0 -BRH:0 -LF:334 -LH:206 -end_of_record -SF:src/rust/parsing/src/bind/command.rs -FN:304,_RNvMs4_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command3new -FN:97,_RNvMs_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB4_12CommandInput10without_id -FN:136,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike4args -FN:133,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike7command -FN:158,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike4args -FN:155,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike7command -FN:320,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputINtNtB9_4util9ResolvingNtB5_7CommandE7resolve -FN:326,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtNtNtB9_10expression5value9Expanding11is_constant -FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_12CommandValueEB6_ -FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_7CommandEB6_ -FN:163,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12BindingInputEB6_ -FN:330,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B10_NtB10_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EE0EBa_ -FN:330,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EBW_16require_constant0EBa_ -FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueE0B8_ -FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs0_0B8_ -FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs_0B8_ -FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandE0B8_ -FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs0_0B8_ -FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs_0B8_ -FN:182,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputE0B8_ -FN:213,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs0_0B8_ -FN:188,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs_0B8_ -FN:338,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0E0Bc_ -FN:342,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0Es_0Bc_ -FN:338,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0E0Bc_ -FN:342,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0Es_0Bc_ -FN:68,_RINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB3_12CommandInputNtNtNtB7_10expression5value9Expanding15map_expressionspEB7_ -FN:75,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspE0B9_ -FN:83,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs0_0B9_ -FN:79,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs_0B9_ -FN:293,_RNvMsu_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command4args -FN:59,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB2_12CommandInputNtNtNtB6_10expression5value9Expanding11is_constant -FN:466,_RNCNvNtNtNtCslo8MYDYmh8N_7parsing4bind7command5testss_22command_gets_flattened0B9_ -FN:149,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike4args -FN:145,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike7command -FN:108,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtNtNtB9_10expression5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_12CommandInputE4from -FNDA:0,_RNvMs4_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command3new -FNDA:2,_RNvMs_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB4_12CommandInput10without_id -FNDA:1,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike4args -FNDA:1,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandValueNtB5_16CommandInputLike7command -FNDA:10,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike4args -FNDA:10,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtB5_16CommandInputLike7command -FNDA:0,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputINtNtB9_4util9ResolvingNtB5_7CommandE7resolve -FNDA:10,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7CommandNtNtNtB9_10expression5value9Expanding11is_constant -FNDA:1,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_12CommandValueEB6_ -FNDA:10,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB2_7CommandEB6_ -FNDA:24,_RINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12BindingInputEB6_ -FNDA:10,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B10_NtB10_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EE0EBa_ -FNDA:10,_RINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB6_7CommandNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBJ_EBW_16require_constant0EBa_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueE0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs0_0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_12CommandValueEs_0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandE0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs0_0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB4_7CommandEs_0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputE0B8_ -FNDA:1,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs0_0B8_ -FNDA:0,_RNCINvNtNtCslo8MYDYmh8N_7parsing4bind7command19regularize_commandsNtB6_12BindingInputEs_0B8_ -FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0E0Bc_ -FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCINvMsf_B12_NtB12_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecBL_EE0Es_0Bc_ -FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0E0Bc_ -FNDA:0,_RNCINvXs6_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB8_7CommandNtNtNtBc_10expression5value9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecBL_EBY_16require_constant0Es_0Bc_ -FNDA:0,_RINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB3_12CommandInputNtNtNtB7_10expression5value9Expanding15map_expressionspEB7_ -FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspE0B9_ -FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs0_0B9_ -FNDA:0,_RNCINvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_12CommandInputNtNtNtB9_10expression5value9Expanding15map_expressionspEs_0B9_ -FNDA:0,_RNvMsu_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB5_7Command4args -FNDA:0,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind7commandNtB2_12CommandInputNtNtNtB6_10expression5value9Expanding11is_constant -FNDA:4,_RNCNvNtNtNtCslo8MYDYmh8N_7parsing4bind7command5testss_22command_gets_flattened0B9_ -FNDA:24,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike4args -FNDA:24,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtB7_12BindingInputNtB5_16CommandInputLike7command -FNDA:2,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind7commandNtNtNtB9_10expression5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_12CommandInputE4from -FNF:25 -FNH:13 -DA:59,0 -DA:60,0 -DA:61,0 -DA:62,0 -DA:63,0 -DA:64,0 -DA:65,0 -DA:66,0 -DA:67,0 -DA:68,0 -DA:69,0 -DA:70,0 -DA:72,0 -DA:73,0 -DA:74,0 -DA:75,0 -DA:76,0 -DA:77,0 -DA:78,0 -DA:79,0 -DA:80,0 -DA:81,0 -DA:82,0 -DA:83,0 -DA:84,0 -DA:85,0 -DA:86,0 -DA:88,0 -DA:89,0 -DA:91,0 -DA:93,0 -DA:97,2 -DA:98,2 -DA:99,2 -DA:100,2 -DA:101,2 -DA:102,2 -DA:103,2 -DA:104,2 -DA:108,2 -DA:109,2 -DA:110,2 -DA:111,2 -DA:112,2 -DA:113,2 -DA:114,2 -DA:115,2 -DA:116,2 -DA:117,2 -DA:118,2 -DA:133,1 -DA:134,1 -DA:135,1 -DA:136,1 -DA:137,1 -DA:138,1 -DA:139,0 -DA:141,1 -DA:145,24 -DA:146,24 -DA:147,24 -DA:149,24 -DA:150,24 -DA:151,24 -DA:155,10 -DA:156,10 -DA:157,10 -DA:158,10 -DA:159,10 -DA:160,10 -DA:163,35 -DA:164,35 -DA:165,35 -DA:166,35 -DA:167,35 -DA:168,35 -DA:169,29 -DA:170,29 -DA:171,29 -DA:172,6 -DA:173,23 -DA:175,29 -DA:177,29 -DA:179,6 -DA:180,6 -DA:181,6 -DA:182,6 -DA:183,6 -DA:184,6 -DA:185,6 -DA:186,6 -DA:187,6 -DA:188,6 -DA:189,6 -DA:191,0 -DA:194,6 -DA:195,6 -DA:197,0 -DA:198,0 -DA:202,6 -DA:204,19 -DA:206,14 -DA:207,4 -DA:208,4 -DA:209,4 -DA:210,4 -DA:211,4 -DA:212,10 -DA:213,10 -DA:214,1 -DA:215,1 -DA:216,9 -DA:217,9 -DA:219,0 -DA:220,0 -DA:225,9 -DA:226,1 -DA:229,0 -DA:230,0 -DA:231,0 -DA:232,0 -DA:233,1 -DA:234,1 -DA:235,1 -DA:236,1 -DA:237,1 -DA:238,1 -DA:239,1 -DA:240,1 -DA:241,0 -DA:242,1 -DA:243,1 -DA:245,8 -DA:246,4 -DA:247,4 -DA:249,8 -DA:250,7 -DA:251,1 -DA:253,0 -DA:257,8 -DA:258,7 -DA:259,1 -DA:261,8 -DA:262,8 -DA:266,0 -DA:267,0 -DA:268,0 -DA:271,12 -DA:272,12 -DA:273,12 -DA:274,12 -DA:275,12 -DA:278,5 -DA:280,35 -DA:293,0 -DA:294,0 -DA:295,0 -DA:296,0 -DA:297,0 -DA:298,0 -DA:300,0 -DA:304,0 -DA:305,0 -DA:306,0 -DA:307,0 -DA:309,0 -DA:310,0 -DA:311,0 -DA:312,0 -DA:314,0 -DA:316,0 -DA:320,0 -DA:321,0 -DA:322,0 -DA:326,10 -DA:327,10 -DA:328,10 -DA:330,20 -DA:331,20 -DA:332,20 -DA:333,20 -DA:335,20 -DA:336,20 -DA:337,20 -DA:338,20 -DA:339,0 -DA:340,0 -DA:341,0 -DA:342,20 -DA:343,0 -DA:344,0 -DA:345,0 -DA:348,20 -DA:349,0 -DA:351,20 -DA:353,20 -DA:466,4 -BRF:0 -BRH:0 -LF:206 -LH:126 -end_of_record -SF:src/rust/parsing/src/bind/foreach.rs -FN:269,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys -FN:251,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys -FN:326,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values -FN:293,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput11has_foreach -FN:300,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput14expand_foreach -FN:310,_RNCNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB8_12BindingInput14expand_foreach00Ba_ -FN:282,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys00B9_ -FN:333,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values00B9_ -FN:307,_RNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB6_12BindingInput14expand_foreach0B8_ -FN:279,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys0B7_ -FN:262,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys0B7_ -FN:332,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values0B7_ -FNDA:4,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys -FNDA:3,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys -FNDA:4,_RNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values -FNDA:12,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput11has_foreach -FNDA:12,_RNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB4_12BindingInput14expand_foreach -FNDA:86,_RNCNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB8_12BindingInput14expand_foreach00Ba_ -FNDA:7,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys00B9_ -FNDA:36,_RNCNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values00B9_ -FNDA:34,_RNCNvMNtNtCslo8MYDYmh8N_7parsing4bind7foreachNtB6_12BindingInput14expand_foreach0B8_ -FNDA:5,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach11expand_keys0B7_ -FNDA:216,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach19expression_fn__keys0B7_ -FNDA:6,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind7foreach21expand_foreach_values0B7_ -FNF:12 -FNH:12 -DA:251,3 -DA:252,3 -DA:253,3 -DA:254,3 -DA:255,0 -DA:256,0 -DA:258,3 -DA:260,3 -DA:261,579 -DA:262,576 -DA:263,30 -DA:264,546 -DA:266,3 -DA:267,3 -DA:269,4 -DA:270,4 -DA:271,4 -DA:272,4 -DA:274,4 -DA:277,4 -DA:278,4 -DA:279,5 -DA:280,5 -DA:281,5 -DA:282,7 -DA:283,3 -DA:284,4 -DA:285,7 -DA:286,5 -DA:287,5 -DA:288,5 -DA:289,4 -DA:290,4 -DA:293,12 -DA:294,12 -DA:295,4 -DA:296,8 -DA:297,8 -DA:298,12 -DA:300,12 -DA:301,12 -DA:302,4 -DA:303,4 -DA:305,0 -DA:307,34 -DA:308,34 -DA:309,34 -DA:310,86 -DA:311,86 -DA:312,0 -DA:313,86 -DA:314,102 -DA:315,102 -DA:316,102 -DA:317,86 -DA:318,86 -DA:319,34 -DA:320,4 -DA:321,8 -DA:322,8 -DA:323,12 -DA:326,4 -DA:327,4 -DA:329,9 -DA:330,5 -DA:331,5 -DA:332,6 -DA:333,36 -DA:334,36 -DA:335,36 -DA:336,36 -DA:337,36 -DA:338,6 -DA:339,5 -DA:342,4 -DA:343,4 -BRF:0 -BRH:0 -LF:83 -LH:79 -end_of_record -SF:src/rust/parsing/src/bind/validation.rs -FN:194,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging5merge -FN:197,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging8coalesce -FN:267,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_16BindingReferenceE4from -FN:277,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging5merge -FN:273,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging8coalesce -FN:185,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_10KeyBindingE4from -FN:203,_RNvMs3_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBinding6unwrap -FN:102,_RNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str -FN:127,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind10validationNtB2_10KeyBindingINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from -FN:148,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtNtB9_10expression5value9Expanding11is_constant -FN:228,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from -FN:254,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtNtB9_10expression5value9Expanding11is_constant -FN:140,_RNvXs_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB4_10KeyBindingINtNtB8_4util9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolve -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsNtB8_12BindingInputE0EBa_ -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope6expandBN_E0EBa_ -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB21_6Define6expand0EBa_ -FN:154,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYBN_B14_16require_constant0EBa_ -FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ -FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsNtB8_12BindingInputE0EBa_ -FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ -FN:257,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB27_6Define6expand0EBa_ -FN:108,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str0B7_ -FNDA:0,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging5merge -FNDA:0,_RNvXs2_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtB9_4util7Merging8coalesce -FNDA:0,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_16BindingReferenceE4from -FNDA:0,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging5merge -FNDA:0,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtB9_4util7Merging8coalesce -FNDA:23,_RNvXs1_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromNtB5_10KeyBindingE4from -FNDA:1,_RNvMs3_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBinding6unwrap -FNDA:29,_RNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str -FNDA:20,_RNvXNtNtCslo8MYDYmh8N_7parsing4bind10validationNtB2_10KeyBindingINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from -FNDA:1,_RNvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_10KeyBindingNtNtNtB9_10expression5value9Expanding11is_constant -FNDA:4,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsktekB2AySAD_5alloc6string6StringE8try_from -FNDA:1,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB5_16BindingReferenceNtNtNtB9_10expression5value9Expanding11is_constant -FNDA:21,_RNvXs_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB4_10KeyBindingINtNtB8_4util9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolve -FNDA:9,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ -FNDA:1,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope10parse_astsNtB8_12BindingInputE0EBa_ -FNDA:21,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B18_NtB18_5Scope6expandBN_E0EBa_ -FNDA:10,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ -FNDA:10,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB21_6Define6expand0EBa_ -FNDA:21,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_10KeyBindingNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvYBN_B14_16require_constant0EBa_ -FNDA:2,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_12BindingInputEEE0EBa_ -FNDA:0,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCINvMsf_B1e_NtB1e_5Scope10parse_astsNtB8_12BindingInputE0EBa_ -FNDA:0,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNCNvMNtB8_7foreachNtB8_12BindingInput14expand_foreach00EBa_ -FNDA:3,_RINvXs5_NtNtCslo8MYDYmh8N_7parsing4bind10validationNtB6_16BindingReferenceNtNtNtBa_10expression5value9Expanding15map_expressionsNCNvMNtBa_6defineNtB27_6Define6expand0EBa_ -FNDA:127,_RNCNvNtNtCslo8MYDYmh8N_7parsing4bind10validation21valid_key_binding_str0B7_ -FNF:16 -FNH:11 -DA:102,29 -DA:103,39 -DA:104,39 -DA:105,39 -DA:106,39 -DA:107,39 -DA:108,127 -DA:109,0 -DA:110,39 -DA:112,0 -DA:113,0 -DA:114,0 -DA:118,29 -DA:119,29 -DA:127,20 -DA:128,20 -DA:130,1 -DA:133,19 -DA:134,19 -DA:136,20 -DA:140,21 -DA:141,21 -DA:142,21 -DA:143,21 -DA:144,21 -DA:148,1 -DA:149,1 -DA:150,1 -DA:151,0 -DA:153,1 -DA:154,72 -DA:155,72 -DA:156,72 -DA:158,72 -DA:159,50 -DA:160,22 -DA:161,12 -DA:162,0 -DA:163,10 -DA:164,10 -DA:165,10 -DA:167,0 -DA:168,0 -DA:169,0 -DA:170,0 -DA:171,0 -DA:172,0 -DA:173,0 -DA:174,0 -DA:175,0 -DA:177,0 -DA:181,72 -DA:185,23 -DA:186,23 -DA:187,23 -DA:188,0 -DA:190,23 -DA:194,0 -DA:195,0 -DA:196,0 -DA:197,0 -DA:198,0 -DA:199,0 -DA:203,1 -DA:204,1 -DA:205,1 -DA:206,0 -DA:208,1 -DA:228,4 -DA:229,4 -DA:230,4 -DA:231,4 -DA:232,4 -DA:233,4 -DA:234,4 -DA:235,4 -DA:237,0 -DA:238,0 -DA:239,0 -DA:242,0 -DA:243,0 -DA:244,0 -DA:246,4 -DA:254,1 -DA:255,1 -DA:256,1 -DA:257,5 -DA:258,5 -DA:259,5 -DA:260,5 -DA:262,5 -DA:263,5 -DA:267,0 -DA:268,0 -DA:269,0 -DA:273,0 -DA:274,0 -DA:275,0 -DA:277,0 -DA:278,0 -DA:279,0 -BRF:0 -BRH:0 -LF:102 -LH:62 -end_of_record -SF:src/rust/parsing/src/define.rs -FN:258,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define12add_to_scope -FN:188,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define3new -FN:268,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define6expand -FN:297,_RNCNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB6_6Define6expand00B8_ -FN:210,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3new0B6_ -FN:228,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3news_0B6_ -FN:290,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define6expand0B6_ -FN:318,_RNvNtNtCslo8MYDYmh8N_7parsing6define5testss_14simple_parsing -FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define12add_to_scope -FNDA:14,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define3new -FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing6defineNtB2_6Define6expand -FNDA:0,_RNCNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB6_6Define6expand00B8_ -FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3new0B6_ -FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define3news_0B6_ -FNDA:16,_RNCNvMNtCslo8MYDYmh8N_7parsing6defineNtB4_6Define6expand0B6_ -FNDA:1,_RNvNtNtCslo8MYDYmh8N_7parsing6define5testss_14simple_parsing -FNF:8 -FNH:5 -DA:188,14 -DA:189,14 -DA:190,14 -DA:191,14 -DA:192,14 -DA:194,14 -DA:195,5 -DA:196,5 -DA:197,5 -DA:198,5 -DA:199,5 -DA:200,0 -DA:201,0 -DA:202,0 -DA:207,14 -DA:208,3 -DA:209,3 -DA:210,3 -DA:211,3 -DA:212,3 -DA:213,0 -DA:214,3 -DA:215,0 -DA:216,0 -DA:217,0 -DA:218,3 -DA:219,3 -DA:220,3 -DA:225,14 -DA:226,4 -DA:227,4 -DA:228,4 -DA:229,4 -DA:230,4 -DA:231,0 -DA:232,4 -DA:233,0 -DA:234,0 -DA:235,0 -DA:236,4 -DA:237,4 -DA:238,4 -DA:243,14 -DA:244,0 -DA:250,14 -DA:251,14 -DA:252,14 -DA:253,14 -DA:254,14 -DA:256,14 -DA:258,13 -DA:259,13 -DA:260,3 -DA:261,3 -DA:263,3 -DA:265,13 -DA:266,13 -DA:268,13 -DA:270,13 -DA:271,3 -DA:272,3 -DA:273,3 -DA:274,0 -DA:275,3 -DA:278,3 -DA:279,3 -DA:280,3 -DA:281,3 -DA:283,0 -DA:285,3 -DA:287,10 -DA:290,16 -DA:291,16 -DA:292,16 -DA:293,2 -DA:294,2 -DA:295,2 -DA:296,2 -DA:297,2 -DA:298,2 -DA:299,2 -DA:300,14 -DA:301,14 -DA:302,0 -DA:303,0 -DA:304,0 -DA:305,14 -DA:306,14 -DA:307,16 -DA:308,13 -DA:318,1 -DA:319,1 -DA:320,1 -DA:321,1 -DA:322,1 -DA:323,1 -DA:324,1 -DA:325,1 -DA:326,1 -DA:327,1 -DA:328,1 -DA:329,1 -DA:330,1 -DA:331,1 -DA:332,1 -DA:333,1 -DA:334,1 -DA:335,1 -DA:336,1 -DA:337,1 -DA:339,1 -DA:340,1 -DA:342,1 -DA:343,1 -DA:344,1 -DA:345,1 -DA:346,1 -DA:347,1 -DA:349,1 -DA:350,1 -DA:351,1 -DA:352,1 -DA:355,1 -DA:356,1 -DA:357,1 -DA:358,1 -DA:359,1 -DA:361,1 -DA:362,1 -DA:363,1 -DA:364,1 -DA:365,1 -DA:366,1 -DA:367,1 -DA:369,1 -BRF:0 -BRH:0 -LF:139 -LH:119 -end_of_record -SF:src/rust/parsing/src/error.rs -FN:78,_RNCNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB7_9Spannable5range0B9_ -FN:379,_RNvMs1F_NtCslo8MYDYmh8N_7parsing5errorNtB6_11ErrorReport3new -FN:71,_RNvXININtCslo8MYDYmh8N_7parsing5error0pEINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpENtB5_9Spannable5rangeB7_ -FN:77,_RNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB5_9Spannable5rangeB7_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB26_7flatten7FlattenINtNtB2a_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBM_EEENCNvMNtB4_4fileNtB4l_7KeyFile3news_0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB2U_3VecBM_ENtB3Q_9Expanding15map_expressionsNCINvMsf_B3S_NtB3S_5Scope10parse_astsB4f_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsIB42_IBN_NtNtB4_4bind12BindingInputEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB33_6string6StringB41_EE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4W_12BindingInput14expand_foreach00E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4S_6Define6expand0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB4_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB27_6string6StringNtNtNtB4_10expression5value5ValueEENCNvMNtBO_7foreachBM_14expand_foreach0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterBM_ENCNvXsq_NtB4_4utilINtB2V_6PluralBM_EINtB2V_9ResolvingINtB2h_3VecBM_EE7resolve0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsB2J_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsINtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandB2J_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueBM_EE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuebEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuedEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2h_3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2J_EEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4e_12BindingInput14expand_foreach00E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4a_6Define6expand0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYB2J_B3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueBM_EB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuebEB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuedEB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2h_3VecNtNtNtB4_4bind7command7CommandEB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecB2J_EEB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3y_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsBM_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandBM_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandIB3c_NtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueNtNtB2e_6string6StringEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuebEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuedEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBM_EEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB45_12BindingInput14expand_foreach00E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvMNtB4_6defineNtB41_6Define6expand0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYBM_B3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYIB3c_NtNtNtB4_4bind7command7CommandEB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueNtNtB2e_6string6StringEB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuebEB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuedEB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringB3b_EB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3q_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCINvMsf_B37_NtB37_5Scope6expandB3u_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCNvYB3u_B3J_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBO_12CommandInputENCNvXsq_NtB4_4utilINtB3k_6PluralB2S_EINtB3k_9ResolvingINtB29_3VecBM_EE7resolve0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsIB1q_IB1G_NtNtB4_4bind12BindingInputEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope6expandB4Y_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB62_12BindingInput14expand_foreach00E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNvMNtB4_6defineNtB5Y_6Define6expand0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecNtNtNtB4_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B1H_INtB37_8IndexMapBN_B1p_ENtB1H_9Expanding15map_expressionsNCNvYB49_B4x_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsB1p_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandB1p_E0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueBN_EE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuebEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuedEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1p_EEEE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB55_12BindingInput14expand_foreach00E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvMNtB4_6defineNtB51_6Define6expand0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYB1p_B4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueBN_EB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuebEB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuedEB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecB1p_EEB4p_16require_constant0E0EEB4_ -FN:167,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB4p_16require_constant0E0EEB4_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs_0B6_ -FN:171,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EE0B6_ -FN:180,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs0_0B6_ -FN:174,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs_0B6_ -FN:298,_RNCNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB8_5Error6report0Ba_ -FN:349,_RNCNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB8_8ErrorSet6report0Ba_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1i_6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB9_4bind7BindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuebENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuedENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuelENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4bind12BindingInputNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode13WhenNoBindingNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode4ModeNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_10expression5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_4bind10validation16BindingReferenceNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB7_8ErrorSetEINtB7_12ErrorContextbE12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB7_8ErrorSetEINtB7_12ErrorContextdE12with_context0B9_ -FN:223,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB7_8ErrorSetEINtB7_12ErrorContextuE12with_context0B9_ -FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ -FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtBP_3num5error15TryFromIntErrorE4fromB7_ -FN:128,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ -FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ -FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ -FN:185,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml3ser5error5ErrorE4fromB7_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtB1m_5error8ErrorSetENtB26_8RawErrorEINtB26_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1m_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4bind7BindingNtNtBN_5error8ErrorSetENtB1o_8RawErrorEINtB1o_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4mode5ModesNtNtBN_5error8ErrorSetENtB1m_8RawErrorEINtB1m_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtB1A_5error8RawErrorEINtB36_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1A_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtB28_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB2a_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtBK_6string6StringENtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1A_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1C_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtCslo8MYDYmh8N_7parsing4bind7BindingENtNtB1g_5error8ErrorSetEINtB1S_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1g_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredINtNtNtBK_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBK_5error8ErrorSetEINtB2E_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredNtNtNtBK_4bind10validation10KeyBindingENtNtBK_5error8ErrorSetEINtB1Z_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBM_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBM_5error8ErrorSetEINtB2C_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtNtBM_5error8ErrorSetEINtB2h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuelENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1g_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1i_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1j_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1l_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4bind12BindingInputNtNtBJ_5error8ErrorSetEINtB1q_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode13WhenNoBindingNtNtBJ_5error8ErrorSetEINtB1r_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode4ModeNtNtBJ_5error8ErrorSetEINtB1h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtBL_5types11parse_error10ParseErrorEINtNtCslo8MYDYmh8N_7parsing5error12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB20_ -FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error5ErrorEINtB1x_12ErrorContextBF_E12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBL_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error8ErrorSetEINtB1x_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing4bind10validation16BindingReferenceNtNtBL_5error8ErrorSetEINtB1I_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultbNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextbE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultdNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextdE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBK_ -FN:97,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageReEBK_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextuE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:100,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultzNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextzE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FN:111,_RNvXs1_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_5ErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB7_4bind7command7CommandENtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4bind7BindingNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4mode5ModesNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtB1h_5types11parse_error10ParseErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8RawErrorEINtB5_12ErrorContextuE12with_contextB7_ -FN:200,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultzNtB5_8RawErrorEINtB5_12ErrorContextzE12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1g_6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB7_4bind7BindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueINtNtB7_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuebENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuedENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuelENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4bind12BindingInputNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode13WhenNoBindingNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode4ModeNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_4bind10validation16BindingReferenceNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB5_8ErrorSetEINtB5_12ErrorContextbE12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB5_8ErrorSetEINtB5_12ErrorContextdE12with_contextB7_ -FN:217,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8ErrorSetEINtB5_12ErrorContextuE12with_contextB7_ -FN:83,_RNvXs0_NtCslo8MYDYmh8N_7parsing5errorINtNtNtCs7micvSKFzzu_4core3ops5range5RangejENtB5_9Spannable5range -FN:289,_RNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB6_5Error6report -FN:348,_RNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB6_8ErrorSet6report -FN:253,_RNvNtCslo8MYDYmh8N_7parsing5error12range_to_pos -FN:266,_RNvNtCslo8MYDYmh8N_7parsing5error38resolve_rhai_pos_from_expression_range -FN:46,_RNvNtCslo8MYDYmh8N_7parsing5error3err -FN:137,_RNvXs3_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc5boxed3BoxNtNtNtCsdKkeGZLW2Fi_4rhai5types5error13EvalAltResultEE4from -FN:159,_RNvXs4_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ErrorE4from -FN:193,_RNvXs6_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ErrorEE4from -FN:237,_RNvXs9_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorNtNtCs7micvSKFzzu_4core3fmt7Display3fmt -FN:361,_RNvXsa_NtCslo8MYDYmh8N_7parsing5errorNtB5_9CharRangeNtNtCs7micvSKFzzu_4core7default7Default7default -FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB7_9Spannable5range0B9_ -FNDA:0,_RNvMs1F_NtCslo8MYDYmh8N_7parsing5errorNtB6_11ErrorReport3new -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing5error0pEINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpENtB5_9Spannable5rangeB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing5errors_0pEINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedpEENtB5_9Spannable5rangeB7_ -FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB26_7flatten7FlattenINtNtB2a_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBM_EEENCNvMNtB4_4fileNtB4l_7KeyFile3news_0EEB4_ -FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB2U_3VecBM_ENtB3Q_9Expanding15map_expressionsNCINvMsf_B3S_NtB3S_5Scope10parse_astsB4f_E0E0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsIB42_IBN_NtNtB4_4bind12BindingInputEEE0E0EEB4_ -FNDA:3,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCINvMsf_B1E_NtB1E_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB33_6string6StringB41_EE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4W_12BindingInput14expand_foreach00E0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_B1C_INtB31_3VecBM_ENtB1C_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4S_6Define6expand0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB4_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB27_6string6StringNtNtNtB4_10expression5value5ValueEENCNvMNtBO_7foreachBM_14expand_foreach0EEB4_ -FNDA:46,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterBM_ENCNvXsq_NtB4_4utilINtB2V_6PluralBM_EINtB2V_9ResolvingINtB2h_3VecBM_EE7resolve0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsB2J_E0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsINtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandB2J_E0E0EEB4_ -FNDA:27,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueBM_EE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuebEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2L_10TypedValuedEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtB2h_3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2J_EEEE0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCINvMsf_B2N_NtB2N_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB4e_12BindingInput14expand_foreach00E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvMNtB4_6defineNtB4a_6Define6expand0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYB2J_B3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueBM_EB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValueINtNtB4_4util6PluralBM_EEB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuebEB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2L_10TypedValuedEB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtB2h_3VecNtNtNtB4_4bind7command7CommandEB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBM_INtB2h_3VecB2J_EEB3y_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBQ_3vec9into_iter8IntoIterNtNtNtB4_10expression5value5ValueENCINvXse_B2L_B2J_NtB2L_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3y_16require_constant0E0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsBM_E0E0EEB4_ -FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandBM_E0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandIB3c_NtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEE0E0EEB4_ -FNDA:27,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValueNtNtB2e_6string6StringEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuebEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtBO_10TypedValuedEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringIB3c_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBM_EEEE0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCINvMsf_BQ_NtBQ_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FNDA:52,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB45_12BindingInput14expand_foreach00E0EEB4_ -FNDA:8,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvMNtB4_6defineNtB41_6Define6expand0E0EEB4_ -FNDA:8,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYBM_B3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYIB3c_NtNtNtB4_4bind7command7CommandEB3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueINtNtB4_4util6PluralNtNtB2e_6string6StringEEB3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValueNtNtB2e_6string6StringEB3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuebEB3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtBO_10TypedValuedEB3q_16require_constant0E0EEB4_ -FNDA:5,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2e_6string6StringB3b_EB3q_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_BO_INtB2c_3VecBM_ENtBO_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB3q_16require_constant0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCINvMsf_B37_NtB37_5Scope6expandB3u_E0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBM_ENCINvXsg_NtNtB4_10expression5valueINtB29_3VecBM_ENtB35_9Expanding15map_expressionsNCNvYB3u_B3J_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB4_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBO_12CommandInputENCNvXsq_NtB4_4utilINtB3k_6PluralB2S_EINtB3k_9ResolvingINtB29_3VecBM_EE7resolve0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsIB1q_IB1G_NtNtB4_4bind12BindingInputEEE0E0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCINvMsf_B2x_NtB2x_5Scope6expandB4Y_E0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB62_12BindingInput14expand_foreach00E0EEB4_ -FNDA:2,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB4_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B2v_INtB3W_8IndexMapBN_B1p_ENtB2v_9Expanding15map_expressionsNCNvMNtB4_6defineNtB5Y_6Define6expand0E0EEB4_ -FNDA:4,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBR_3vec3VecNtNtNtB4_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBN_B1p_ENCINvXsd_B1H_INtB37_8IndexMapBN_B1p_ENtB1H_9Expanding15map_expressionsNCNvYB49_B4x_16require_constant0E0EEB4_ -FNDA:6,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsB1p_E0E0EEB4_ -FNDA:9,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsINtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB4_4bind12BindingInputEEE0E0EEB4_ -FNDA:3,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope10parse_astsNtNtB4_4bind12BindingInputE0E0EEB4_ -FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandB1p_E0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueBN_EE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuebEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtB1r_10TypedValuedEE0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1p_EEEE0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCINvMsf_B1t_NtB1t_5Scope6expandNtNtNtB4_4bind10validation10KeyBindingE0E0EEB4_ -FNDA:34,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNCNvMNtNtB4_4bind7foreachNtB55_12BindingInput14expand_foreach00E0EEB4_ -FNDA:14,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvMNtB4_6defineNtB51_6Define6expand0E0EEB4_ -FNDA:13,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYB1p_B4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueBN_EB4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValueINtNtB4_4util6PluralBN_EEB4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuebEB4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtB1r_10TypedValuedEB4p_16require_constant0E0EEB4_ -FNDA:10,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtBR_3vec3VecNtNtNtB4_4bind7command7CommandEB4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBN_INtNtBR_3vec3VecB1p_EEB4p_16require_constant0E0EEB4_ -FNDA:0,_RINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB4_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBN_B1p_ENCINvXsc_B1r_INtB2O_7HashMapBN_B1p_ENtB1r_9Expanding15map_expressionsNCNvYNtNtNtB4_4bind10validation10KeyBindingB4p_16require_constant0E0EEB4_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtB28_7flatten7FlattenINtNtB2c_6option8IntoIterINtNtCsktekB2AySAD_5alloc3vec3VecBO_EEENCNvMNtB6_4fileNtB4n_7KeyFile3news_0EEs_0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2W_3VecBO_ENtB3S_9Expanding15map_expressionsNCINvMsf_B3U_NtB3U_5Scope10parse_astsB4h_E0E0EEs_0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsIB44_IBP_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FNDA:7,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EE0B6_ -FNDA:7,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCINvMsf_B1G_NtB1G_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB35_6string6StringB43_EE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4Y_12BindingInput14expand_foreach00E0EEs_0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EE0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_B1E_INtB33_3VecBO_ENtB1E_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4U_6Define6expand0E0EEs_0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EE0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtB6_4bind12BindingInputINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB29_6string6StringNtNtNtB6_10expression5value5ValueEENCNvMNtBQ_7foreachBO_14expand_foreach0EEs_0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EE0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterBO_ENCNvXsq_NtB6_4utilINtB2X_6PluralBO_EINtB2X_9ResolvingINtB2j_3VecBO_EE7resolve0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsB2L_E0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsINtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EE0B6_ -FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandB2L_E0E0EEs_0B6_ -FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EE0B6_ -FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueBO_EE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuebEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2N_10TypedValuedEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtB2j_3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2L_EEEE0E0EEs_0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCINvMsf_B2P_NtB2P_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB4g_12BindingInput14expand_foreach00E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvMNtB6_6defineNtB4c_6Define6expand0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYB2L_B3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueBO_EB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValueINtNtB6_4util6PluralBO_EEB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuebEB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2N_10TypedValuedEB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtB2j_3VecNtNtNtB6_4bind7command7CommandEB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBO_INtB2j_3VecB2L_EEB3A_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtCsktekB2AySAD_5alloc6string6StringINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtBS_3vec9into_iter8IntoIterNtNtNtB6_10expression5value5ValueENCINvXse_B2N_B2L_NtB2N_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3A_16require_constant0E0EEs_0B6_ -FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs0_0B6_ -FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsBO_E0E0EEs_0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EE0B6_ -FNDA:8,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandBO_E0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandIB3e_NtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEE0E0EEs_0B6_ -FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EE0B6_ -FNDA:62,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValueNtNtB2g_6string6StringEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuebEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtBQ_10TypedValuedEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringIB3e_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0E0EEs_0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCINvMsf_BS_NtBS_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FNDA:112,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EE0B6_ -FNDA:112,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB47_12BindingInput14expand_foreach00E0EEs_0B6_ -FNDA:16,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EE0B6_ -FNDA:16,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvMNtB6_6defineNtB43_6Define6expand0E0EEs_0B6_ -FNDA:17,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EE0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs0_0B6_ -FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYBO_B3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYIB3e_NtNtNtB6_4bind7command7CommandEB3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueINtNtB6_4util6PluralNtNtB2g_6string6StringEEB3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValueNtNtB2g_6string6StringEB3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuebEB3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtBQ_10TypedValuedEB3s_16require_constant0E0EEs_0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EE0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtB2g_6string6StringB3d_EB3s_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_10expression5value5ValueINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_BQ_INtB2e_3VecBO_ENtBQ_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB3s_16require_constant0E0EEs_0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCINvMsf_B39_NtB39_5Scope6expandB3w_E0E0EEs_0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EE0B6_ -FNDA:10,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterBO_ENCINvXsg_NtNtB6_10expression5valueINtB2b_3VecBO_ENtB37_9Expanding15map_expressionsNCNvYB3w_B3L_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsNtNtNtB6_4bind7command7CommandINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCsktekB2AySAD_5alloc3vec9into_iter8IntoIterNtBQ_12CommandInputENCNvXsq_NtB6_4utilINtB3m_6PluralB2U_EINtB3m_9ResolvingINtB2b_3VecBO_EE7resolve0EEs_0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsIB1s_IB1I_NtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FNDA:3,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EE0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCINvMsf_B2z_NtB2z_5Scope6expandB50_E0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB64_12BindingInput14expand_foreach00E0EEs_0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EE0B6_ -FNDA:2,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB6_10expression5value5ValueEEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B2x_INtB3Y_8IndexMapBP_B1r_ENtB2x_9Expanding15map_expressionsNCNvMNtB6_6defineNtB60_6Define6expand0E0EEs_0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EE0B6_ -FNDA:5,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringINtNtBT_3vec3VecNtNtNtB6_10expression5value5ValueEEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtCshdQd8zdVCjC_8indexmap3map4iter8IntoIterBP_B1r_ENCINvXsd_B1J_INtB39_8IndexMapBP_B1r_ENtB1J_9Expanding15map_expressionsNCNvYB4b_B4z_16require_constant0E0EEs_0B6_ -FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs0_0B6_ -FNDA:6,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsB1r_E0E0EEs_0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EE0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsINtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_4bind12BindingInputEEE0E0EEs_0B6_ -FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EE0B6_ -FNDA:4,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope10parse_astsNtNtB6_4bind12BindingInputE0E0EEs_0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EE0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandB1r_E0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueBP_EE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuebEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtB1t_10TypedValuedEE0E0EEs_0B6_ -FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EE0B6_ -FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1r_EEEE0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCINvMsf_B1v_NtB1v_5Scope6expandNtNtNtB6_4bind10validation10KeyBindingE0E0EEs_0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EE0B6_ -FNDA:34,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNCNvMNtNtB6_4bind7foreachNtB57_12BindingInput14expand_foreach00E0EEs_0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EE0B6_ -FNDA:20,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvMNtB6_6defineNtB53_6Define6expand0E0EEs_0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EE0B6_ -FNDA:13,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYB1r_B4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueBP_EB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValueINtNtB6_4util6PluralBP_EEB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuebEB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtB1t_10TypedValuedEB4r_16require_constant0E0EEs_0B6_ -FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EE0B6_ -FNDA:11,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtBT_3vec3VecNtNtNtB6_4bind7command7CommandEB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapBP_INtNtBT_3vec3VecB1r_EEB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EE0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs0_0B6_ -FNDA:0,_RNCINvNtCslo8MYDYmh8N_7parsing5error14flatten_errorsTNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueEINtNtNtNtCs7micvSKFzzu_4core4iter8adapters3map3MapINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map8IntoIterBP_B1r_ENCINvXsc_B1t_INtB2Q_7HashMapBP_B1r_ENtB1t_9Expanding15map_expressionsNCNvYNtNtNtB6_4bind10validation10KeyBindingB4r_16require_constant0E0EEs_0B6_ -FNDA:0,_RNCNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB8_5Error6report0Ba_ -FNDA:14,_RNCNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB8_8ErrorSet6report0Ba_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1i_6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:2,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB9_4bind7BindingENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuebENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuedENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB9_10expression5value10TypedValuelENtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4bind12BindingInputNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode13WhenNoBindingNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB9_4mode4ModeNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:1,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_10expression5value5ValueNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB9_4bind10validation16BindingReferenceNtB7_8ErrorSetEINtB7_12ErrorContextB1d_E12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB7_8ErrorSetEINtB7_12ErrorContextbE12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB7_8ErrorSetEINtB7_12ErrorContextdE12with_context0B9_ -FNDA:0,_RNCNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB7_8ErrorSetEINtB7_12ErrorContextuE12with_context0B9_ -FNDA:18,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ -FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtBP_3num5error15TryFromIntErrorE4fromB7_ -FNDA:0,_RNvXs2_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ -FNDA:2,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_8RawErrorE4fromB7_ -FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorE4fromB7_ -FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtNtNtCsbTJfyT4wEp0_4toml3ser5error5ErrorE4fromB7_ -FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtB1m_5error8ErrorSetENtB26_8RawErrorEINtB26_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1m_ -FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4bind7BindingNtNtBN_5error8ErrorSetENtB1o_8RawErrorEINtB1o_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ -FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultIB4_NtNtCslo8MYDYmh8N_7parsing4mode5ModesNtNtBN_5error8ErrorSetENtB1m_8RawErrorEINtB1m_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBN_ -FNDA:3,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtB1A_5error8RawErrorEINtB36_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1A_ -FNDA:4,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtB28_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB2a_ -FNDA:47,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtBK_6string6StringENtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1A_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1C_ -FNDA:10,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtCslo8MYDYmh8N_7parsing4bind7BindingENtNtB1g_5error8ErrorSetEINtB1S_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1g_ -FNDA:60,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredINtNtNtBK_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBK_5error8ErrorSetEINtB2E_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:60,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtCslo8MYDYmh8N_7parsing4util8RequiredNtNtNtBK_4bind10validation10KeyBindingENtNtBK_5error8ErrorSetEINtB1Z_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:128,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBM_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtBM_5error8ErrorSetEINtB2C_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FNDA:46,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtNtBM_5error8ErrorSetEINtB2h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuelENtNtBM_5error8ErrorSetEINtB1G_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBM_ -FNDA:13,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1g_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1i_ -FNDA:90,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtB1j_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB1l_ -FNDA:10,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4bind12BindingInputNtNtBJ_5error8ErrorSetEINtB1q_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FNDA:6,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode13WhenNoBindingNtNtBJ_5error8ErrorSetEINtB1r_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FNDA:16,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtCslo8MYDYmh8N_7parsing4mode4ModeNtNtBJ_5error8ErrorSetEINtB1h_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBJ_ -FNDA:25,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtBL_5types11parse_error10ParseErrorEINtNtCslo8MYDYmh8N_7parsing5error12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEB20_ -FNDA:71,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error5ErrorEINtB1x_12ErrorContextBF_E12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBL_ -FNDA:71,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtNtBL_5error8ErrorSetEINtB1x_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ -FNDA:5,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCslo8MYDYmh8N_7parsing4bind10validation16BindingReferenceNtNtBL_5error8ErrorSetEINtB1I_12ErrorContextBF_E10with_rangeINtNtNtB8_3ops5range5RangejEEBL_ -FNDA:3,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultbNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextbE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:0,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultdNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextdE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:126,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageNtNtCsktekB2AySAD_5alloc6string6StringEBK_ -FNDA:4,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8ErrorSetEINtBI_12ErrorContextuE12with_messageReEBK_ -FNDA:1,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultuNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextuE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:2,_RINvYINtNtCs7micvSKFzzu_4core6result6ResultzNtNtCslo8MYDYmh8N_7parsing5error8RawErrorEINtBI_12ErrorContextzE10with_rangeINtNtNtB8_3ops5range5RangejEEBK_ -FNDA:71,_RNvXs1_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_5ErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_INtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB7_4bind7command7CommandENtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4bind7BindingNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultIBA_NtNtB7_4mode5ModesNtB5_8ErrorSetENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:3,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:4,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8RawErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:25,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtCsdKkeGZLW2Fi_4rhai3ast3ast3ASTNtNtNtB1h_5types11parse_error10ParseErrorEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:1,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8RawErrorEINtB5_12ErrorContextuE12with_contextB7_ -FNDA:2,_RNvXs7_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultzNtB5_8RawErrorEINtB5_12ErrorContextzE12with_contextB7_ -FNDA:60,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:60,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtB7_4util8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:47,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB1g_6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:10,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtCsktekB2AySAD_5alloc3vec3VecNtNtB7_4bind7BindingENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:128,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueINtNtB7_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:46,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuebENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuedENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultINtNtNtB7_10expression5value10TypedValuelENtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:10,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4bind12BindingInputNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:6,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode13WhenNoBindingNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:16,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtB7_4mode4ModeNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:13,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:90,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtCsktekB2AySAD_5alloc6string6StringNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:71,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_10expression5value5ValueNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:5,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultNtNtNtB7_4bind10validation16BindingReferenceNtB5_8ErrorSetEINtB5_12ErrorContextB1b_E12with_contextB7_ -FNDA:3,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultbNtB5_8ErrorSetEINtB5_12ErrorContextbE12with_contextB7_ -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultdNtB5_8ErrorSetEINtB5_12ErrorContextdE12with_contextB7_ -FNDA:130,_RNvXs8_NtCslo8MYDYmh8N_7parsing5errorINtNtCs7micvSKFzzu_4core6result6ResultuNtB5_8ErrorSetEINtB5_12ErrorContextuE12with_contextB7_ -FNDA:602,_RNvXs0_NtCslo8MYDYmh8N_7parsing5errorINtNtNtCs7micvSKFzzu_4core3ops5range5RangejENtB5_9Spannable5range -FNDA:14,_RNvMs11_NtCslo8MYDYmh8N_7parsing5errorNtB6_5Error6report -FNDA:13,_RNvMs12_NtCslo8MYDYmh8N_7parsing5errorNtB6_8ErrorSet6report -FNDA:13,_RNvNtCslo8MYDYmh8N_7parsing5error12range_to_pos -FNDA:2,_RNvNtCslo8MYDYmh8N_7parsing5error38resolve_rhai_pos_from_expression_range -FNDA:8,_RNvNtCslo8MYDYmh8N_7parsing5error3err -FNDA:1,_RNvXs3_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc5boxed3BoxNtNtNtCsdKkeGZLW2Fi_4rhai5types5error13EvalAltResultEE4from -FNDA:27,_RNvXs4_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ErrorE4from -FNDA:19,_RNvXs6_NtCslo8MYDYmh8N_7parsing5errorNtB5_8ErrorSetINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ErrorEE4from -FNDA:0,_RNvXs9_NtCslo8MYDYmh8N_7parsing5errorNtB5_5ErrorNtNtCs7micvSKFzzu_4core3fmt7Display3fmt -FNDA:1,_RNvXsa_NtCslo8MYDYmh8N_7parsing5errorNtB5_9CharRangeNtNtCs7micvSKFzzu_4core7default7Default7default -FNF:29 -FNH:23 -DA:46,8 -DA:47,8 -DA:48,8 -DA:71,0 -DA:72,0 -DA:73,0 -DA:77,0 -DA:78,0 -DA:79,0 -DA:83,602 -DA:84,602 -DA:85,602 -DA:97,201 -DA:98,201 -DA:99,201 -DA:100,602 -DA:101,602 -DA:102,602 -DA:104,0 -DA:106,602 -DA:111,71 -DA:112,71 -DA:113,71 -DA:114,0 -DA:115,0 -DA:116,0 -DA:117,0 -DA:118,0 -DA:119,0 -DA:122,71 -DA:128,18 -DA:129,18 -DA:130,18 -DA:131,18 -DA:132,18 -DA:133,18 -DA:137,1 -DA:138,1 -DA:139,1 -DA:159,27 -DA:160,27 -DA:161,27 -DA:162,27 -DA:163,27 -DA:167,400 -DA:168,400 -DA:169,400 -DA:171,628 -DA:172,400 -DA:173,400 -DA:174,400 -DA:175,400 -DA:177,400 -DA:178,13 -DA:180,606 -DA:182,400 -DA:185,2 -DA:186,2 -DA:187,2 -DA:188,2 -DA:189,2 -DA:193,19 -DA:194,19 -DA:195,19 -DA:200,37 -DA:201,37 -DA:202,30 -DA:203,7 -DA:204,7 -DA:205,7 -DA:206,7 -DA:207,7 -DA:208,7 -DA:209,7 -DA:212,37 -DA:217,695 -DA:218,695 -DA:219,690 -DA:220,5 -DA:221,5 -DA:222,5 -DA:223,5 -DA:224,5 -DA:227,695 -DA:237,0 -DA:238,0 -DA:239,0 -DA:240,0 -DA:241,0 -DA:243,0 -DA:244,0 -DA:248,0 -DA:249,0 -DA:250,0 -DA:253,13 -DA:256,13 -DA:257,0 -DA:258,0 -DA:259,13 -DA:260,13 -DA:261,13 -DA:262,13 -DA:263,13 -DA:264,13 -DA:266,2 -DA:267,2 -DA:268,2 -DA:269,2 -DA:270,2 -DA:271,2 -DA:272,2 -DA:273,2 -DA:274,2 -DA:275,2 -DA:276,2 -DA:277,2 -DA:278,2 -DA:279,2 -DA:280,0 -DA:281,0 -DA:282,0 -DA:283,2 -DA:289,14 -DA:290,14 -DA:291,14 -DA:292,14 -DA:293,14 -DA:294,14 -DA:295,14 -DA:296,0 -DA:297,0 -DA:298,0 -DA:300,2 -DA:301,2 -DA:302,2 -DA:303,2 -DA:304,12 -DA:306,31 -DA:307,17 -DA:308,0 -DA:309,17 -DA:313,17 -DA:314,13 -DA:315,13 -DA:316,13 -DA:317,2 -DA:318,2 -DA:319,2 -DA:320,2 -DA:321,2 -DA:322,11 -DA:323,11 -DA:324,11 -DA:325,4 -DA:329,14 -DA:330,13 -DA:331,13 -DA:332,13 -DA:333,13 -DA:335,1 -DA:336,1 -DA:337,1 -DA:338,1 -DA:339,1 -DA:340,1 -DA:341,1 -DA:343,14 -DA:348,13 -DA:349,14 -DA:350,13 -DA:361,1 -DA:362,1 -DA:363,1 -DA:364,1 -DA:365,1 -DA:366,1 -DA:379,0 -DA:380,0 -DA:381,0 -DA:382,0 -DA:383,0 -DA:384,0 -BRF:0 -BRH:0 -LF:189 -LH:149 -end_of_record -SF:src/rust/parsing/src/expression.rs -FN:233,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope17pop_command_queue0B9_ -FN:227,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope20add_to_command_queue0B9_ -FN:213,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope3get0B9_ -FN:206,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope5unset0B9_ -FN:232,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope17pop_command_queue -FN:226,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope20add_to_command_queue -FN:209,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3get -FN:191,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3set -FN:202,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope5unset -FN:175,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3new -FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_4bind12BindingInputEEEB8_ -FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB6_5value5ValueEB8_ -FN:159,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB8_4bind12BindingInputEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueINtNtB8_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuebEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuedEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1H_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_5value5ValueEEEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB8_4bind7command7CommandEEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtB6_5value5ValueEB8_ -FN:129,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtNtB8_4bind10validation10KeyBindingEB8_ -FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0Ba_ -FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtB8_5value5ValueE0Ba_ -FN:160,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuebEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuedEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1J_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_5value5ValueEEEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtB8_5value5ValueE0Ba_ -FN:143,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0Ba_ -FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope17pop_command_queue0B9_ -FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope20add_to_command_queue0B9_ -FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope3get0B9_ -FNDA:0,_RNCNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB7_5Scope5unset0B9_ -FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope17pop_command_queue -FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope20add_to_command_queue -FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3get -FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3set -FNDA:0,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope5unset -FNDA:30,_RNvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB5_5Scope3new -FNDA:13,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_4bind12BindingInputEEEB8_ -FNDA:6,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB6_5value5ValueEB8_ -FNDA:3,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope10parse_astsNtNtB8_4bind12BindingInputEB8_ -FNDA:47,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueINtNtB8_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEB8_ -FNDA:64,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEB8_ -FNDA:3,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuebEEB8_ -FNDA:0,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtB6_5value10TypedValuedEEB8_ -FNDA:4,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1H_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB6_5value5ValueEEEEB8_ -FNDA:10,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB8_4bind7command7CommandEEB8_ -FNDA:13,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtB6_5value5ValueEB8_ -FNDA:21,_RINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB6_5Scope6expandNtNtNtB8_4bind10validation10KeyBindingEB8_ -FNDA:13,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0Ba_ -FNDA:8,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtB8_5value5ValueE0Ba_ -FNDA:9,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0Ba_ -FNDA:3,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0Ba_ -FNDA:32,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0Ba_ -FNDA:0,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuebEE0Ba_ -FNDA:0,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtB8_5value10TypedValuedEE0Ba_ -FNDA:3,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1J_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB8_5value5ValueEEEE0Ba_ -FNDA:11,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0Ba_ -FNDA:13,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtB8_5value5ValueE0Ba_ -FNDA:10,_RNCINvMsf_NtCslo8MYDYmh8N_7parsing10expressionNtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0Ba_ -FNF:14 -FNH:5 -DA:129,162 -DA:130,162 -DA:131,162 -DA:133,162 -DA:134,0 -DA:135,0 -DA:136,0 -DA:137,0 -DA:138,0 -DA:139,0 -DA:140,0 -DA:141,0 -DA:142,0 -DA:143,162 -DA:144,72 -DA:146,72 -DA:147,151 -DA:148,79 -DA:149,79 -DA:151,72 -DA:152,71 -DA:153,71 -DA:154,71 -DA:155,71 -DA:156,72 -DA:157,162 -DA:159,22 -DA:160,30 -DA:161,30 -DA:162,5 -DA:163,25 -DA:164,25 -DA:165,25 -DA:166,25 -DA:167,25 -DA:168,23 -DA:169,23 -DA:170,30 -DA:171,16 -DA:172,22 -DA:175,30 -DA:176,30 -DA:177,30 -DA:178,30 -DA:179,30 -DA:181,30 -DA:182,30 -DA:183,30 -DA:184,30 -DA:185,30 -DA:186,30 -DA:187,30 -DA:188,30 -DA:189,30 -DA:191,0 -DA:192,0 -DA:193,0 -DA:194,0 -DA:196,0 -DA:197,0 -DA:198,0 -DA:199,0 -DA:200,0 -DA:202,0 -DA:203,0 -DA:204,0 -DA:205,0 -DA:206,0 -DA:207,0 -DA:209,0 -DA:210,0 -DA:211,0 -DA:212,0 -DA:213,0 -DA:214,0 -DA:215,0 -DA:216,0 -DA:218,0 -DA:219,0 -DA:220,0 -DA:221,0 -DA:222,0 -DA:224,0 -DA:226,0 -DA:227,0 -DA:228,0 -DA:230,0 -DA:232,0 -DA:233,0 -DA:234,0 -DA:235,0 -BRF:0 -BRH:0 -LF:99 -LH:48 -end_of_record -SF:src/rust/parsing/src/expression/value.rs -FN:742,_RINvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtBa_4util6PluralpENtB6_9Expanding15map_expressionspEBa_ -FN:632,_RNCNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_9Expanding11is_constant0Bb_ -FN:406,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from0Bb_ -FN:412,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_froms_0Bb_ -FN:631,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_9Expanding11is_constantB9_ -FN:739,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtB9_4util6PluralpENtB5_9Expanding11is_constantB9_ -FN:959,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesv_0pEINtB5_10TypedValuepEINtNtB9_4util9ResolvingBT_E7resolveB9_ -FN:981,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesx_0pEINtB5_10TypedValuepENtNtB9_4util7Merging5mergeB9_ -FN:391,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from -FN:545,_RNvXs8_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtCs7micvSKFzzu_4core7default7Default7default -FN:551,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging8coalesce -FN:874,_RNvXso_NtNtCslo8MYDYmh8N_7parsing10expression5valuelINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuelEE4from -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB2l_E0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB2l_E0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueB1J_EE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2l_EEEE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3c_12BindingInput14expand_foreach00EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB38_6Define6expand0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB2l_B2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueB1J_EB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecB2l_EEB2x_16require_constant0EBa_ -FN:634,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB2x_16require_constant0EBa_ -FN:892,_RNvXsq_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4from -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2U_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4b_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB47_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2A_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3Q_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3M_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB36_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB32_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtB2i_12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB2i_12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNCNvMNtB2i_7foreachNtB2i_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3z_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB2I_IB2Z_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4G_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB4C_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2v_6Define6expand0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ -FN:775,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2D_6Define6expand0EBa_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB28_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEEENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind15BindingDocInputENtB5_9Expanding11is_constantB9_ -FN:769,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind23CombinedBindingDocInputENtB5_9Expanding11is_constantB9_ -FN:968,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ -FN:968,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_IB1m_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB31_12BindingInput14expand_foreach00EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2X_6Define6expand0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB1l_E0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB1l_E0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandIBP_NtNtNtBa_4bind7command7CommandEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtBT_6string6StringEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1l_EEEE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2c_12BindingInput14expand_foreach00EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB28_6Define6expand0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB1l_B1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYIBP_NtNtNtBa_4bind7command7CommandEB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtBT_6string6StringEB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB1x_16require_constant0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:728,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCNvYBO_B1Q_16require_constant0EBa_ -FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ -FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ValueENtB5_9Expanding11is_constantB9_ -FN:725,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB9_4bind7command7CommandENtB5_9Expanding11is_constantB9_ -FN:620,_RNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBF_10expression5value9Expanding16require_constantBF_ -FN:448,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FN:131,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_boolNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:190,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_someINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FN:186,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor12visit_stringNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:178,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_f64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:174,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:135,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapINtNtCs14aAdjk2HcL_13toml_datetime2de20DatetimeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5table14TableMapAccessEBd_ -FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18MapRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FN:208,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQNtNtCsbTJfyT4wEp0_4toml5value15MapDeserializerEBd_ -FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5array14ArraySeqAccessEBd_ -FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18SeqRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FN:197,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQNtNtCsbTJfyT4wEp0_4toml5value15SeqDeserializerEBd_ -FN:182,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_strNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:161,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:148,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ -FN:86,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ -FN:118,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2I_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1E_12BindingInput14expand_foreach00EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1A_6Define6expand0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYBO_BZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2j_3vec3VecBO_EEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEBZ_16require_constant0EBa_ -FN:674,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingBZ_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1u_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2J_12BindingInput14expand_foreach00EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2F_6Define6expand0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvYBO_B24_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1a_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2o_12BindingInput14expand_foreach00EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2k_6Define6expand0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvYBO_B1J_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEB18_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FN:852,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB2n_E0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB2n_E0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueB1L_EE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2n_EEEE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB3e_12BindingInput14expand_foreach00E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB3a_6Define6expand0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB2n_B2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueB1L_EB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecB2n_EEB2z_16require_constant0E0Bc_ -FN:640,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB2z_16require_constant0E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIB28_IB2p_NtNtBc_4bind12BindingInputEEE0E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB45_12BindingInput14expand_foreach00E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB41_6Define6expand0E0Bc_ -FN:657,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvYBQ_B2B_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2K_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBQ_EEEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB1G_12BindingInput14expand_foreach00E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB1C_6Define6expand0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYBQ_B11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2l_3vec3VecBQ_EEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEB11_16require_constant0E0Bc_ -FN:683,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB11_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_IB1o_NtNtBc_4bind12BindingInputEEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB33_12BindingInput14expand_foreach00E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2Z_6Define6expand0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB1n_E0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB1n_E0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandIBR_NtNtNtBc_4bind7command7CommandEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtBV_6string6StringEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1n_EEEE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB2e_12BindingInput14expand_foreach00E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2a_6Define6expand0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB1n_B1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYIBR_NtNtNtBc_4bind7command7CommandEB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtBV_6string6StringEB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB1z_16require_constant0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FN:733,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCNvYBQ_B1S_16require_constant0E0Bc_ -FN:253,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3new0Bb_ -FN:259,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3news_0Bb_ -FN:429,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FN:435,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FN:455,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FN:459,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FN:478,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FN:483,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FN:505,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from0Bb_ -FN:513,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_froms_0Bb_ -FN:649,_RNCNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1y_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEEENtB7_9Expanding11is_constant0Bb_ -FN:669,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constant0Bb_ -FN:670,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constants_0Bb_ -FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEENtB7_9Expanding11is_constant0Bb_ -FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB7_5ValueENtB7_9Expanding11is_constant0Bb_ -FN:726,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBb_4bind7command7CommandENtB7_9Expanding11is_constant0Bb_ -FN:625,_RNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBN_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1D_9Expanding16require_constant0B1H_ -FN:625,_RNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBH_10expression5value9Expanding16require_constant0BH_ -FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBb_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_9Expanding16require_constant0Bb_ -FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_9Expanding16require_constant0Bb_ -FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB7_9Expanding16require_constant0Bb_ -FN:625,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB7_9Expanding16require_constant0Bb_ -FN:625,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB6_9Expanding16require_constant0Ba_ -FN:625,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtBa_10expression5value9Expanding16require_constant0Ba_ -FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FN:806,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FN:816,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FN:829,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding11is_constantB9_ -FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtB5_9Expanding11is_constantB9_ -FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedENtB5_9Expanding11is_constantB9_ -FN:846,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtB5_9Expanding11is_constantB9_ -FN:925,_RNvXst_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE4fromB9_ -FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtB18_9ResolvingINtNtB1t_3vec3VecB1p_EE7resolveB9_ -FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtB9_4util9ResolvingB15_E7resolveB9_ -FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtB9_4util9ResolvingbE7resolveB9_ -FN:946,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtB9_4util9ResolvingdE7resolveB9_ -FN:977,_RNvXsx_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB18_7Merging8coalesceB9_ -FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding16require_constantB9_ -FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding16require_constantB9_ -FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB5_9Expanding16require_constantB9_ -FN:620,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB5_9Expanding16require_constantB9_ -FN:620,_RNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB4_9Expanding16require_constantB8_ -FN:245,_RNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5Value3new -FN:363,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value16interp_to_string -FN:269,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value19match_to_expression -FN:332,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value20string_to_expression -FN:305,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value22check_unmatched_braces -FN:61,_RNvXNtNtCslo8MYDYmh8N_7parsing10expression5valueNtB2_10ExpressionNtNtCs7micvSKFzzu_4core3fmt7Display3fmt -FN:127,_RNvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB2_12ValueVisitorNtB17_7Visitor9expecting -FN:422,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FN:497,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from -FN:554,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging5merge -FN:70,_RNvXs_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB4_10ExpressionNtNtCs7micvSKFzzu_4core3cmp9PartialEq2eq -FN:583,_RNvXsa_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingBN_E7resolve -FN:589,_RNvXsb_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolve -FN:665,_RNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtB5_9Expanding11is_constant -FN:883,_RNvXsp_NtNtCslo8MYDYmh8N_7parsing10expression5valuedINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuedEE4from -FN:901,_RNvXsr_NtNtCslo8MYDYmh8N_7parsing10expression5valuebINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuebEE4from -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2i_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3y_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3u_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1Y_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3d_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB39_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2k_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3A_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3w_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB22_12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB22_12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNCNvMNtB22_7foreachNtB22_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3d_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB3x_3vec3VecBO_EEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2t_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2p_6Define6expand0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecBO_EE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB1G_12BindingInputEEE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1G_12BindingInputE0EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNCNvMNtB1G_7foreachNtB1G_12BindingInput14expand_foreach00EBa_ -FN:712,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2W_6Define6expand0EBa_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingEENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueENtB5_9Expanding11is_constantB9_ -FN:709,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceENtB5_9Expanding11is_constantB9_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2L_12BindingInput14expand_foreach00EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2H_6Define6expand0EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1e_12BindingInputEEE0EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1e_12BindingInputE0EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNCNvMNtB1e_7foreachNtB1e_12BindingInput14expand_foreach00EBa_ -FN:757,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2o_6Define6expand0EBa_ -FN:751,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FN:751,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB5_9Expanding11is_constantB9_ -FN:913,_RNvXss_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4fromB9_ -FN:620,_RNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtB8_10expression5value9Expanding16require_constantB8_ -FN:991,_RNvNtNtNtCslo8MYDYmh8N_7parsing10expression5value5testss_14parse_datetime -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB26_IB2n_NtNtBa_4bind12BindingInputEEE0EBa_ -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB43_12BindingInput14expand_foreach00EBa_ -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3Z_6Define6expand0EBa_ -FN:651,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvYBO_B2z_16require_constant0EBa_ -FN:648,_RNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEENtB5_9Expanding11is_constantB9_ -FN:620,_RNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBL_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1B_9Expanding16require_constantB1F_ -FN:471,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FNDA:0,_RINvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtBa_4util6PluralpENtB6_9Expanding15map_expressionspEBa_ -FNDA:0,_RNCNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_9Expanding11is_constant0Bb_ -FNDA:0,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from0Bb_ -FNDA:0,_RNCNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_froms_0Bb_ -FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesc_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesh_0pEINtNtB9_4util6PluralpENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesv_0pEINtB5_10TypedValuepEINtNtB9_4util9ResolvingBT_E7resolveB9_ -FNDA:0,_RNvXININtNtCslo8MYDYmh8N_7parsing10expression5valuesx_0pEINtB5_10TypedValuepENtNtB9_4util7Merging5mergeB9_ -FNDA:0,_RNvXs3_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_from -FNDA:0,_RNvXs8_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtCs7micvSKFzzu_4core7default7Default7default -FNDA:0,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging8coalesce -FNDA:0,_RNvXso_NtNtCslo8MYDYmh8N_7parsing10expression5valuelINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuelEE4from -FNDA:6,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB2l_E0EBa_ -FNDA:9,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:13,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB2l_E0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueB1J_EE0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEE0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FNDA:10,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2l_EEEE0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FNDA:34,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3c_12BindingInput14expand_foreach00EBa_ -FNDA:14,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB38_6Define6expand0EBa_ -FNDA:13,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB2l_B2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueB1J_EB2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralB1J_EEB2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB2x_16require_constant0EBa_ -FNDA:10,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtB1N_3vec3VecNtNtNtBa_4bind7command7CommandEB2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1J_INtNtB1N_3vec3VecB2l_EEB2x_16require_constant0EBa_ -FNDA:0,_RINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB2x_16require_constant0EBa_ -FNDA:68,_RNvXsq_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsktekB2AySAD_5alloc6string6StringINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4from -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2U_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4b_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB47_6Define6expand0EBa_ -FNDA:22,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2A_3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:12,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:136,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3Q_12BindingInput14expand_foreach00EBa_ -FNDA:28,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3M_6Define6expand0EBa_ -FNDA:18,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:9,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:102,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FNDA:23,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3f_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3b_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB36_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB32_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIB1r_NtB2i_12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB2i_12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNCNvMNtB2i_7foreachNtB2i_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3z_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB2I_IB2Z_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB4G_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB29_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB4C_6Define6expand0EBa_ -FNDA:10,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind15BindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2v_6Define6expand0EBa_ -FNDA:4,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1s_12BindingInputEEE0EBa_ -FNDA:3,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1s_12BindingInputE0EBa_ -FNDA:34,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNCNvMNtB1s_7foreachNtB1s_12BindingInput14expand_foreach00EBa_ -FNDA:5,_RINvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtBa_4bind23CombinedBindingDocInputENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2D_6Define6expand0EBa_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_9Expanding11is_constantB9_ -FNDA:6,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FNDA:5,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB28_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind15BindingDocInputENtB5_9Expanding11is_constantB9_ -FNDA:1,_RNvXsj_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionNtNtB9_4bind23CombinedBindingDocInputENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ -FNDA:19,_RNvXsw_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEEEINtNtB9_4util9ResolvingB2d_E7resolveB9_ -FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_IB1m_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EE0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB31_12BindingInput14expand_foreach00EBa_ -FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2X_6Define6expand0EBa_ -FNDA:13,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ -FNDA:2,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsB1l_E0EBa_ -FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:4,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:4,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandB1l_E0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandIBP_NtNtNtBa_4bind7command7CommandEE0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEE0EBa_ -FNDA:27,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtBT_6string6StringEE0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringIBP_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1l_EEEE0EBa_ -FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FNDA:52,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2c_12BindingInput14expand_foreach00EBa_ -FNDA:8,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB28_6Define6expand0EBa_ -FNDA:8,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYB1l_B1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYIBP_NtNtNtBa_4bind7command7CommandEB1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtBT_6string6StringEEB1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtBT_6string6StringEB1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEB1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEB1x_16require_constant0EBa_ -FNDA:5,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBT_6string6StringBO_EB1x_16require_constant0EBa_ -FNDA:0,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingB1x_16require_constant0EBa_ -FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:10,_RINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandENtB6_9Expanding15map_expressionsNCNvYBO_B1Q_16require_constant0EBa_ -FNDA:0,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEENtB5_9Expanding11is_constantB9_ -FNDA:103,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB5_5ValueENtB5_9Expanding11is_constantB9_ -FNDA:10,_RNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtB9_4bind7command7CommandENtB5_9Expanding11is_constantB9_ -FNDA:10,_RNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBF_10expression5value9Expanding16require_constantBF_ -FNDA:157,_RNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FNDA:3,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_boolNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor10visit_someINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FNDA:70,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor12visit_stringNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_f64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:28,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_i64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:1,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapINtNtCs14aAdjk2HcL_13toml_datetime2de20DatetimeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FNDA:60,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5table14TableMapAccessEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18MapRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_mapQNtNtCsbTJfyT4wEp0_4toml5value15MapDeserializerEBd_ -FNDA:11,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5array14ArraySeqAccessEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQINtNtNtNtCs9GlaLKreasA_5serde7private2de7content18SeqRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBd_ -FNDA:3,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_seqQNtNtCsbTJfyT4wEp0_4toml5value15SeqDeserializerEBd_ -FNDA:57,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_strNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u32NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB9_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB3_12ValueVisitorNtB18_7Visitor9visit_u64NtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEBd_ -FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB11_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:0,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:72,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ -FNDA:7,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ -FNDA:39,_RINvXs0_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ -FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value17UsizeDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtB15_5value18StringDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:0,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeINtNtNtNtCs9GlaLKreasA_5serde7private2de7content22ContentRefDeserializerNtNtNtCsbTJfyT4wEp0_4toml2de5error5ErrorEEBa_ -FNDA:77,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtCsbTJfyT4wEp0_4toml5value5ValueEBa_ -FNDA:7,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer12DeserializerEBa_ -FNDA:149,_RINvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtNtNtNtCsbTJfyT4wEp0_4toml2de12deserializer5value17ValueDeserializerEBa_ -FNDA:16,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsBO_E0EBa_ -FNDA:37,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:25,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:3,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0EBa_ -FNDA:90,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuebEE0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtB6_10TypedValuedEE0EBa_ -FNDA:7,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2I_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBO_EEEE0EBa_ -FNDA:21,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FNDA:30,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandNtNtNtBa_4bind10validation10KeyBindingE0EBa_ -FNDA:228,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1E_12BindingInput14expand_foreach00EBa_ -FNDA:53,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1A_6Define6expand0EBa_ -FNDA:119,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYBO_BZ_16require_constant0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEBZ_16require_constant0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEBZ_16require_constant0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuebEBZ_16require_constant0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtB6_10TypedValuedEBZ_16require_constant0EBa_ -FNDA:34,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2j_3vec3VecBO_EEBZ_16require_constant0EBa_ -FNDA:21,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEBZ_16require_constant0EBa_ -FNDA:0,_RINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB6_5ValueNtB6_9Expanding15map_expressionsNCNvYNtNtNtBa_4bind10validation10KeyBindingBZ_16require_constant0EBa_ -FNDA:24,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1u_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:6,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:47,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:68,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2J_12BindingInput14expand_foreach00EBa_ -FNDA:30,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2F_6Define6expand0EBa_ -FNDA:46,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvYBO_B24_16require_constant0EBa_ -FNDA:14,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1a_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:6,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:64,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:68,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2o_12BindingInput14expand_foreach00EBa_ -FNDA:17,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2k_6Define6expand0EBa_ -FNDA:64,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB6_9Expanding15map_expressionsNCNvYBO_B1J_16require_constant0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:3,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:10,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FNDA:3,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ -FNDA:10,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuebENtB6_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBa_4bind7command7CommandEB18_16require_constant0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuedENtB6_9Expanding15map_expressionsNCNvYBO_B18_16require_constant0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB1N_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB6_10TypedValuelENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB1J_6Define6expand0EBa_ -FNDA:6,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB2n_E0E0Bc_ -FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FNDA:4,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB2n_E0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueB1L_EE0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEE0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FNDA:11,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB2n_EEEE0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FNDA:34,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB3e_12BindingInput14expand_foreach00E0Bc_ -FNDA:20,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB3a_6Define6expand0E0Bc_ -FNDA:13,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB2n_B2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueB1L_EB2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralB1L_EEB2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB2z_16require_constant0E0Bc_ -FNDA:11,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtB1P_3vec3VecNtNtNtBc_4bind7command7CommandEB2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapB1L_INtNtB1P_3vec3VecB2n_EEB2z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsc_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB2z_16require_constant0E0Bc_ -FNDA:2,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIB28_IB2p_NtNtBc_4bind12BindingInputEEE0E0Bc_ -FNDA:3,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FNDA:5,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FNDA:0,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB45_12BindingInput14expand_foreach00E0Bc_ -FNDA:2,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB41_6Define6expand0E0Bc_ -FNDA:5,_RNCINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1z_3vec3VecNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvYBQ_B2B_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FNDA:8,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEE0E0Bc_ -FNDA:62,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2K_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedBQ_EEEE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEE0E0Bc_ -FNDA:20,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB1G_12BindingInput14expand_foreach00E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB1C_6Define6expand0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYBQ_B11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB2l_3vec3VecBQ_EEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandEB11_16require_constant0E0Bc_ -FNDA:0,_RNCINvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_5ValueNtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB11_16require_constant0E0Bc_ -FNDA:2,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_IB1o_NtNtBc_4bind12BindingInputEEE0E0Bc_ -FNDA:5,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FNDA:7,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EE0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB33_12BindingInput14expand_foreach00E0Bc_ -FNDA:2,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB8_5ValueEENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2Z_6Define6expand0E0Bc_ -FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsBQ_E0E0Bc_ -FNDA:4,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsB1n_E0E0Bc_ -FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBc_4bind12BindingInputEEE0E0Bc_ -FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope10parse_astsNtNtBc_4bind12BindingInputE0E0Bc_ -FNDA:8,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandB1n_E0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandIBR_NtNtNtBc_4bind7command7CommandEE0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEE0E0Bc_ -FNDA:62,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValueNtNtBV_6string6StringEE0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuebEE0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtB8_10TypedValuedEE0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringIBR_INtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedB1n_EEEE0E0Bc_ -FNDA:20,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandNtNtNtBc_4bind10validation10KeyBindingE0E0Bc_ -FNDA:112,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNCNvMNtNtBc_4bind7foreachNtB2e_12BindingInput14expand_foreach00E0Bc_ -FNDA:16,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvMNtBc_6defineNtB2a_6Define6expand0E0Bc_ -FNDA:17,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYB1n_B1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYIBR_NtNtNtBc_4bind7command7CommandEB1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueINtNtBc_4util6PluralNtNtBV_6string6StringEEB1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValueNtNtBV_6string6StringEB1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuebEB1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtB8_10TypedValuedEB1z_16require_constant0E0Bc_ -FNDA:34,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtBV_6string6StringBQ_EB1z_16require_constant0E0Bc_ -FNDA:0,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB8_5ValueENtB8_9Expanding15map_expressionsNCNvYNtNtNtBc_4bind10validation10KeyBindingB1z_16require_constant0E0Bc_ -FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCINvMsf_Ba_NtBa_5Scope6expandBQ_E0E0Bc_ -FNDA:10,_RNCINvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBc_4bind7command7CommandENtB8_9Expanding15map_expressionsNCNvYBQ_B1S_16require_constant0E0Bc_ -FNDA:29,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3new0Bb_ -FNDA:86,_RNCNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5Value3news_0Bb_ -FNDA:0,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FNDA:0,_RNCNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FNDA:10,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FNDA:24,_RNCNvXs5_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtCsbTJfyT4wEp0_4toml5value5ValueINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FNDA:0,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4from0Bb_ -FNDA:0,_RNCNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB7_5ValueE4froms_0Bb_ -FNDA:35,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from0Bb_ -FNDA:0,_RNCNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_froms_0Bb_ -FNDA:0,_RNCNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1y_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEEENtB7_9Expanding11is_constant0Bb_ -FNDA:7,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constant0Bb_ -FNDA:13,_RNCNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB7_5ValueNtB7_9Expanding11is_constants_0Bb_ -FNDA:0,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB7_5ValueEENtB7_9Expanding11is_constant0Bb_ -FNDA:214,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtB7_5ValueENtB7_9Expanding11is_constant0Bb_ -FNDA:10,_RNCNvXsg_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtBb_4bind7command7CommandENtB7_9Expanding11is_constant0Bb_ -FNDA:0,_RNCNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBN_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1D_9Expanding16require_constant0B1H_ -FNDA:0,_RNCNvYINtNtCsktekB2AySAD_5alloc3vec3VecNtNtNtCslo8MYDYmh8N_7parsing4bind7command7CommandENtNtNtBH_10expression5value9Expanding16require_constant0BH_ -FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtBb_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB7_9Expanding16require_constant0Bb_ -FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB7_9Expanding16require_constant0Bb_ -FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB7_9Expanding16require_constant0Bb_ -FNDA:0,_RNCNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB7_9Expanding16require_constant0Bb_ -FNDA:12,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB6_9Expanding16require_constant0Ba_ -FNDA:0,_RNCNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtBa_10expression5value9Expanding16require_constant0Ba_ -FNDA:58,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FNDA:4,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FNDA:19,_RNvXsk_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtNtCs7micvSKFzzu_4core7default7Default7defaultB9_ -FNDA:10,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FNDA:50,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FNDA:3,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FNDA:1,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FNDA:1,_RNvXsl_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtCsbTJfyT4wEp0_4toml5value5ValueE8try_fromB9_ -FNDA:10,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FNDA:50,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FNDA:11,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FNDA:1,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FNDA:1,_RNvXsm_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelEINtNtCs7micvSKFzzu_4core7convert7TryFromNtB5_5ValueE8try_fromB9_ -FNDA:6,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding11is_constantB9_ -FNDA:10,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsn_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuelENtB5_9Expanding11is_constantB9_ -FNDA:2,_RNvXst_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE4fromB9_ -FNDA:47,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEINtB18_9ResolvingINtNtB1t_3vec3VecB1p_EE7resolveB9_ -FNDA:64,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEINtNtB9_4util9ResolvingB15_E7resolveB9_ -FNDA:3,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuebEINtNtB9_4util9ResolvingbE7resolveB9_ -FNDA:0,_RNvXsu_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValuedEINtNtB9_4util9ResolvingdE7resolveB9_ -FNDA:12,_RNvXsx_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB18_7Merging8coalesceB9_ -FNDA:46,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding16require_constantB9_ -FNDA:64,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringENtB5_9Expanding16require_constantB9_ -FNDA:3,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuebENtB5_9Expanding16require_constantB9_ -FNDA:0,_RNvYINtNtNtCslo8MYDYmh8N_7parsing10expression5value10TypedValuedENtB5_9Expanding16require_constantB9_ -FNDA:89,_RNvYNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueNtB4_9Expanding16require_constantB8_ -FNDA:312,_RNvMs2_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5Value3new -FNDA:0,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value16interp_to_string -FNDA:35,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value19match_to_expression -FNDA:190,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value20string_to_expression -FNDA:158,_RNvNtNtCslo8MYDYmh8N_7parsing10expression5value22check_unmatched_braces -FNDA:83,_RNvXNtNtCslo8MYDYmh8N_7parsing10expression5valueNtB2_10ExpressionNtNtCs7micvSKFzzu_4core3fmt7Display3fmt -FNDA:0,_RNvXNvXs1_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB8_9BareValueNtNtCsjNmRiKsxu1e_10serde_core2de11Deserialize11deserializeNtB2_12ValueVisitorNtB17_7Visitor9expecting -FNDA:102,_RNvXs4_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_9BareValueINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FNDA:106,_RNvXs7_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtCs7micvSKFzzu_4core7convert7TryFromNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicE8try_from -FNDA:11,_RNvXs9_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtNtB9_4util7Merging5merge -FNDA:3,_RNvXs_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB4_10ExpressionNtNtCs7micvSKFzzu_4core3cmp9PartialEq2eq -FNDA:5,_RNvXsa_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingBN_E7resolve -FNDA:13,_RNvXsb_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueINtNtB9_4util9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolve -FNDA:329,_RNvXse_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtB5_5ValueNtB5_9Expanding11is_constant -FNDA:1,_RNvXsp_NtNtCslo8MYDYmh8N_7parsing10expression5valuedINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuedEE4from -FNDA:13,_RNvXsr_NtNtCslo8MYDYmh8N_7parsing10expression5valuebINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValuebEE4from -FNDA:24,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2i_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:6,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:68,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3y_12BindingInput14expand_foreach00EBa_ -FNDA:30,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueINtNtBa_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3u_6Define6expand0EBa_ -FNDA:4,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1Y_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3d_12BindingInput14expand_foreach00EBa_ -FNDA:5,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB39_6Define6expand0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuebEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuedEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2C_12BindingInput14expand_foreach00EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB6_10TypedValuelEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2y_6Define6expand0EBa_ -FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB2k_3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB3A_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3w_6Define6expand0EBa_ -FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB22_12BindingInputEEE0EBa_ -FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB22_12BindingInputE0EBa_ -FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNCNvMNtB22_7foreachNtB22_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3d_6Define6expand0EBa_ -FNDA:7,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:8,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:7,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB3x_3vec3VecBO_EEE0EBa_ -FNDA:34,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2t_12BindingInput14expand_foreach00EBa_ -FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2p_6Define6expand0EBa_ -FNDA:10,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecBO_EE0EBa_ -FNDA:2,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecIBP_NtB1G_12BindingInputEEE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1G_12BindingInputE0EBa_ -FNDA:0,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNCNvMNtB1G_7foreachNtB1G_12BindingInput14expand_foreach00EBa_ -FNDA:3,_RINvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtBa_4bind10validation16BindingReferenceENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2W_6Define6expand0EBa_ -FNDA:6,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FNDA:1,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuebEENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuedEENtB5_9Expanding11is_constantB9_ -FNDA:0,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_10TypedValuelEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingEENtB5_9Expanding11is_constantB9_ -FNDA:2,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueENtB5_9Expanding11is_constantB9_ -FNDA:1,_RNvXsf_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB9_4bind10validation16BindingReferenceENtB5_9Expanding11is_constantB9_ -FNDA:10,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:3,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:34,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB2L_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredINtB6_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2H_6Define6expand0EBa_ -FNDA:10,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsINtNtCsktekB2AySAD_5alloc3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB1e_12BindingInputEEE0EBa_ -FNDA:3,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtB1e_12BindingInputE0EBa_ -FNDA:34,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNCNvMNtB1e_7foreachNtB1e_12BindingInput14expand_foreach00EBa_ -FNDA:13,_RINvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtBa_4util8RequiredNtNtNtBa_4bind10validation10KeyBindingENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB2o_6Define6expand0EBa_ -FNDA:3,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredINtB5_10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_9Expanding11is_constantB9_ -FNDA:3,_RNvXsi_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util8RequiredNtNtNtB9_4bind10validation10KeyBindingENtB5_9Expanding11is_constantB9_ -FNDA:46,_RNvXss_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtB9_4util6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_10TypedValueBN_EE4fromB9_ -FNDA:21,_RNvYNtNtNtCslo8MYDYmh8N_7parsing4bind10validation10KeyBindingNtNtNtB8_10expression5value9Expanding16require_constantB8_ -FNDA:1,_RNvNtNtNtCslo8MYDYmh8N_7parsing10expression5value5testss_14parse_datetime -FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsIB26_IB2n_NtNtBa_4bind12BindingInputEEE0EBa_ -FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope10parse_astsNtNtBa_4bind12BindingInputE0EBa_ -FNDA:4,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCINvMsf_B8_NtB8_5Scope6expandBO_E0EBa_ -FNDA:0,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNCNvMNtNtBa_4bind7foreachNtB43_12BindingInput14expand_foreach00EBa_ -FNDA:2,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB6_5ValueEEENtB6_9Expanding15map_expressionsNCNvMNtBa_6defineNtB3Z_6Define6expand0EBa_ -FNDA:4,_RINvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1x_3vec3VecNtB6_5ValueEENtB6_9Expanding15map_expressionsNCNvYBO_B2z_16require_constant0EBa_ -FNDA:0,_RNvXsd_NtNtCslo8MYDYmh8N_7parsing10expression5valueINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtB1w_3vec3VecINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtB5_5ValueEEENtB5_9Expanding11is_constantB9_ -FNDA:4,_RNvYINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringINtNtBL_3vec3VecNtNtNtCslo8MYDYmh8N_7parsing10expression5value5ValueEENtB1B_9Expanding16require_constantB1F_ -FNDA:82,_RNvXs6_NtNtCslo8MYDYmh8N_7parsing10expression5valueNtNtNtCsdKkeGZLW2Fi_4rhai5types7dynamic7DynamicINtNtCs7micvSKFzzu_4core7convert4FromNtB5_5ValueE4from -FNF:87 -FNH:61 -DA:61,83 -DA:62,83 -DA:63,83 -DA:64,83 -DA:65,83 -DA:66,83 -DA:70,3 -DA:71,3 -DA:72,0 -DA:73,3 -DA:75,3 -DA:76,3 -DA:77,3 -DA:78,3 -DA:86,118 -DA:87,118 -DA:88,118 -DA:90,118 -DA:91,118 -DA:94,0 -DA:95,118 -DA:97,118 -DA:118,233 -DA:119,233 -DA:120,233 -DA:127,0 -DA:128,0 -DA:129,0 -DA:131,3 -DA:132,3 -DA:133,3 -DA:135,28 -DA:136,28 -DA:137,28 -DA:138,28 -DA:139,28 -DA:140,28 -DA:142,0 -DA:143,0 -DA:144,0 -DA:146,28 -DA:148,0 -DA:149,0 -DA:150,0 -DA:151,0 -DA:152,0 -DA:153,0 -DA:155,0 -DA:156,0 -DA:157,0 -DA:159,0 -DA:161,0 -DA:162,0 -DA:163,0 -DA:164,0 -DA:165,0 -DA:166,0 -DA:168,0 -DA:169,0 -DA:170,0 -DA:172,0 -DA:174,0 -DA:175,0 -DA:176,0 -DA:178,0 -DA:179,0 -DA:180,0 -DA:182,57 -DA:183,57 -DA:184,57 -DA:186,70 -DA:187,70 -DA:188,70 -DA:190,0 -DA:191,0 -DA:192,0 -DA:194,0 -DA:195,0 -DA:197,14 -DA:198,14 -DA:199,14 -DA:201,14 -DA:202,43 -DA:203,29 -DA:204,29 -DA:205,14 -DA:206,14 -DA:208,61 -DA:209,61 -DA:210,61 -DA:212,61 -DA:213,1 -DA:214,1 -DA:216,0 -DA:217,60 -DA:219,60 -DA:220,60 -DA:221,86 -DA:222,26 -DA:223,26 -DA:224,26 -DA:226,0 -DA:227,0 -DA:228,0 -DA:232,60 -DA:233,61 -DA:236,233 -DA:237,233 -DA:245,312 -DA:246,312 -DA:247,3 -DA:248,0 -DA:249,44 -DA:250,1 -DA:251,190 -DA:252,14 -DA:253,29 -DA:254,29 -DA:255,29 -DA:256,14 -DA:258,60 -DA:259,86 -DA:260,86 -DA:261,86 -DA:262,86 -DA:263,60 -DA:266,312 -DA:269,35 -DA:270,35 -DA:271,14 -DA:272,14 -DA:273,14 -DA:274,14 -DA:275,14 -DA:276,2 -DA:277,2 -DA:278,2 -DA:280,12 -DA:281,14 -DA:282,14 -DA:283,14 -DA:284,14 -DA:285,14 -DA:286,14 -DA:288,21 -DA:289,21 -DA:290,21 -DA:291,0 -DA:292,0 -DA:293,0 -DA:294,0 -DA:295,21 -DA:296,21 -DA:297,21 -DA:298,21 -DA:299,21 -DA:300,21 -DA:301,21 -DA:303,35 -DA:305,158 -DA:306,158 -DA:307,0 -DA:308,0 -DA:309,0 -DA:310,0 -DA:312,0 -DA:313,0 -DA:314,0 -DA:315,0 -DA:317,158 -DA:318,3 -DA:319,3 -DA:320,3 -DA:321,3 -DA:323,3 -DA:324,3 -DA:325,3 -DA:326,3 -DA:328,155 -DA:329,155 -DA:330,158 -DA:332,190 -DA:333,190 -DA:335,190 -DA:336,190 -DA:339,200 -DA:340,35 -DA:341,35 -DA:342,25 -DA:343,10 -DA:344,10 -DA:345,8 -DA:346,8 -DA:347,10 -DA:349,10 -DA:350,10 -DA:351,10 -DA:352,0 -DA:354,165 -DA:355,156 -DA:356,9 -DA:357,9 -DA:358,2 -DA:359,7 -DA:360,9 -DA:361,190 -DA:363,0 -DA:364,0 -DA:365,0 -DA:366,0 -DA:367,0 -DA:368,0 -DA:369,0 -DA:370,0 -DA:371,0 -DA:372,0 -DA:373,0 -DA:374,0 -DA:375,0 -DA:376,0 -DA:378,0 -DA:382,0 -DA:383,0 -DA:391,0 -DA:392,0 -DA:393,0 -DA:394,0 -DA:395,0 -DA:396,0 -DA:397,0 -DA:399,0 -DA:403,0 -DA:404,0 -DA:405,0 -DA:406,0 -DA:407,0 -DA:408,0 -DA:409,0 -DA:411,0 -DA:412,0 -DA:413,0 -DA:414,0 -DA:415,0 -DA:418,0 -DA:422,102 -DA:423,102 -DA:424,0 -DA:425,0 -DA:426,0 -DA:428,0 -DA:429,0 -DA:430,0 -DA:432,0 -DA:433,0 -DA:434,0 -DA:435,0 -DA:436,0 -DA:437,0 -DA:439,0 -DA:440,0 -DA:441,16 -DA:442,86 -DA:444,102 -DA:448,157 -DA:449,157 -DA:450,0 -DA:451,0 -DA:452,0 -DA:454,5 -DA:455,10 -DA:456,5 -DA:458,23 -DA:459,24 -DA:460,23 -DA:462,10 -DA:463,0 -DA:464,10 -DA:465,109 -DA:467,157 -DA:471,82 -DA:472,82 -DA:473,0 -DA:474,16 -DA:475,0 -DA:476,66 -DA:477,0 -DA:478,0 -DA:479,0 -DA:481,0 -DA:482,0 -DA:483,0 -DA:484,0 -DA:487,0 -DA:488,0 -DA:490,82 -DA:497,106 -DA:498,106 -DA:499,0 -DA:500,106 -DA:501,5 -DA:502,5 -DA:503,5 -DA:504,5 -DA:505,35 -DA:506,5 -DA:507,5 -DA:508,101 -DA:509,0 -DA:510,0 -DA:511,0 -DA:512,0 -DA:513,0 -DA:514,0 -DA:515,0 -DA:516,101 -DA:517,0 -DA:518,101 -DA:519,0 -DA:520,101 -DA:521,9 -DA:522,9 -DA:523,0 -DA:524,92 -DA:525,0 -DA:526,92 -DA:527,92 -DA:528,92 -DA:529,92 -DA:530,92 -DA:531,92 -DA:532,92 -DA:533,92 -DA:535,0 -DA:537,106 -DA:545,0 -DA:546,0 -DA:547,0 -DA:551,0 -DA:552,0 -DA:553,0 -DA:554,11 -DA:555,11 -DA:556,1 -DA:557,1 -DA:558,1 -DA:559,1 -DA:560,1 -DA:562,3 -DA:563,3 -DA:564,3 -DA:565,1 -DA:566,2 -DA:567,2 -DA:569,1 -DA:571,0 -DA:573,8 -DA:574,8 -DA:575,0 -DA:577,2 -DA:579,11 -DA:583,5 -DA:584,5 -DA:585,5 -DA:589,13 -DA:590,13 -DA:591,13 -DA:592,13 -DA:593,13 -DA:594,13 -DA:620,237 -DA:621,237 -DA:622,237 -DA:624,237 -DA:625,237 -DA:626,226 -DA:627,237 -DA:631,0 -DA:632,0 -DA:633,0 -DA:634,112 -DA:635,112 -DA:636,112 -DA:638,112 -DA:639,112 -DA:640,125 -DA:641,6 -DA:642,106 -DA:643,106 -DA:644,112 -DA:648,0 -DA:649,0 -DA:650,0 -DA:651,14 -DA:652,14 -DA:653,14 -DA:655,14 -DA:656,14 -DA:657,17 -DA:658,0 -DA:659,14 -DA:660,14 -DA:661,14 -DA:665,329 -DA:666,329 -DA:667,72 -DA:668,45 -DA:669,7 -DA:670,13 -DA:671,196 -DA:673,329 -DA:674,718 -DA:675,718 -DA:676,718 -DA:678,718 -DA:679,216 -DA:680,110 -DA:681,110 -DA:682,103 -DA:683,90 -DA:684,82 -DA:685,8 -DA:686,8 -DA:687,8 -DA:688,8 -DA:689,8 -DA:691,90 -DA:692,41 -DA:694,62 -DA:697,10 -DA:698,112 -DA:699,270 -DA:702,270 -DA:704,718 -DA:709,16 -DA:710,16 -DA:711,16 -DA:712,375 -DA:713,375 -DA:714,375 -DA:716,375 -DA:717,375 -DA:718,375 -DA:719,375 -DA:721,375 -DA:725,113 -DA:726,224 -DA:727,113 -DA:728,170 -DA:729,170 -DA:730,170 -DA:732,170 -DA:733,339 -DA:734,7 -DA:735,170 -DA:739,0 -DA:740,0 -DA:741,0 -DA:742,0 -DA:743,0 -DA:744,0 -DA:746,0 -DA:747,0 -DA:751,6 -DA:752,6 -DA:753,3 -DA:754,3 -DA:756,6 -DA:757,120 -DA:758,120 -DA:759,120 -DA:761,120 -DA:762,31 -DA:763,89 -DA:765,120 -DA:769,33 -DA:770,33 -DA:771,28 -DA:772,5 -DA:774,33 -DA:775,816 -DA:776,816 -DA:777,816 -DA:779,816 -DA:780,655 -DA:781,161 -DA:783,816 -DA:806,81 -DA:807,81 -DA:808,81 -DA:816,65 -DA:817,65 -DA:819,65 -DA:820,65 -DA:821,65 -DA:829,73 -DA:830,73 -DA:831,73 -DA:832,11 -DA:834,62 -DA:835,62 -DA:836,62 -DA:839,73 -DA:846,19 -DA:847,19 -DA:848,19 -DA:849,0 -DA:851,19 -DA:852,480 -DA:853,480 -DA:854,480 -DA:856,480 -DA:857,84 -DA:858,84 -DA:859,83 -DA:861,30 -DA:862,30 -DA:863,30 -DA:865,53 -DA:868,396 -DA:870,480 -DA:874,0 -DA:875,0 -DA:876,0 -DA:877,0 -DA:879,0 -DA:883,1 -DA:884,1 -DA:885,1 -DA:886,0 -DA:888,1 -DA:892,68 -DA:893,68 -DA:894,68 -DA:895,0 -DA:897,68 -DA:901,13 -DA:902,13 -DA:903,13 -DA:904,0 -DA:906,13 -DA:913,46 -DA:914,46 -DA:915,46 -DA:916,0 -DA:918,46 -DA:925,2 -DA:926,2 -DA:927,2 -DA:928,2 -DA:933,2 -DA:935,0 -DA:937,2 -DA:946,114 -DA:947,114 -DA:948,113 -DA:949,113 -DA:950,113 -DA:951,113 -DA:952,114 -DA:959,0 -DA:960,0 -DA:961,0 -DA:968,19 -DA:969,19 -DA:970,0 -DA:971,19 -DA:973,19 -DA:977,12 -DA:978,12 -DA:979,12 -DA:981,0 -DA:982,0 -DA:983,0 -DA:991,1 -DA:992,1 -DA:993,1 -DA:994,1 -DA:995,1 -DA:996,1 -DA:997,1 -BRF:0 -BRH:0 -LF:605 -LH:409 -end_of_record -SF:src/rust/parsing/src/file.rs -FN:226,_RNCNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes0B5_ -FN:218,_RNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes -FN:179,_RNCNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB6_7KeyFile3news1_00B8_ -FN:135,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3new0B6_ -FN:162,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news0_0B6_ -FN:166,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news1_0B6_ -FN:149,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news_0B6_ -FN:119,_RNvMNtCslo8MYDYmh8N_7parsing4fileNtB2_7KeyFile3new -FN:231,_RNvNtCslo8MYDYmh8N_7parsing4file18parse_bytes_helper -FN:392,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreach0B7_ -FN:393,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreachs_0B7_ -FN:582,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressions0B7_ -FN:584,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss0_0B7_ -FN:585,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss1_0B7_ -FN:586,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss2_0B7_ -FN:587,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss3_0B7_ -FN:583,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss_0B7_ -FNDA:0,_RNCNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes0B5_ -FNDA:0,_RNvNtCslo8MYDYmh8N_7parsing4file22parse_keybinding_bytes -FNDA:19,_RNCNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB6_7KeyFile3news1_00B8_ -FNDA:5,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3new0B6_ -FNDA:0,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news0_0B6_ -FNDA:10,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news1_0B6_ -FNDA:10,_RNCNvMNtCslo8MYDYmh8N_7parsing4fileNtB4_7KeyFile3news_0B6_ -FNDA:13,_RNvMNtCslo8MYDYmh8N_7parsing4fileNtB2_7KeyFile3new -FNDA:1,_RNvNtCslo8MYDYmh8N_7parsing4file18parse_bytes_helper -FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreach0B7_ -FNDA:9,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_14expand_foreachs_0B7_ -FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressions0B7_ -FNDA:1,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss0_0B7_ -FNDA:1,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss1_0B7_ -FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss2_0B7_ -FNDA:2,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss3_0B7_ -FNDA:3,_RNCNvNtNtCslo8MYDYmh8N_7parsing4file5testss_21eval_mode_expressionss_0B7_ -FNF:17 -FNH:14 -DA:119,13 -DA:120,13 -DA:123,13 -DA:124,13 -DA:125,0 -DA:126,0 -DA:127,0 -DA:129,13 -DA:133,13 -DA:134,13 -DA:135,13 -DA:136,13 -DA:137,4 -DA:138,4 -DA:139,4 -DA:141,9 -DA:145,13 -DA:146,13 -DA:147,13 -DA:148,13 -DA:149,13 -DA:151,13 -DA:152,0 -DA:153,0 -DA:154,0 -DA:156,13 -DA:159,13 -DA:160,13 -DA:161,13 -DA:162,13 -DA:164,13 -DA:165,13 -DA:166,13 -DA:167,10 -DA:168,10 -DA:169,10 -DA:177,10 -DA:178,10 -DA:179,19 -DA:180,10 -DA:181,10 -DA:182,10 -DA:183,8 -DA:184,2 -DA:185,2 -DA:186,2 -DA:190,0 -DA:191,0 -DA:192,0 -DA:195,10 -DA:196,13 -DA:198,13 -DA:199,7 -DA:200,7 -DA:201,7 -DA:202,7 -DA:203,7 -DA:205,6 -DA:207,13 -DA:218,0 -DA:219,0 -DA:220,0 -DA:221,0 -DA:222,0 -DA:223,0 -DA:224,0 -DA:225,0 -DA:226,0 -DA:229,0 -DA:231,1 -DA:232,1 -DA:233,1 -DA:234,1 -DA:235,1 -DA:392,9 -DA:393,9 -DA:582,2 -DA:583,3 -DA:584,1 -DA:585,1 -DA:586,2 -DA:587,2 -BRF:0 -BRH:0 -LF:88 -LH:67 -end_of_record -SF:src/rust/parsing/src/mode.rs -FN:309,_RNvXs6_NtCslo8MYDYmh8N_7parsing4modeNtB5_9ModeInputINtNtB7_4util9ResolvingNtB5_4ModeE7resolve -FN:294,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3get -FN:211,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3new -FN:184,_RNvMsp_NtCslo8MYDYmh8N_7parsing4modeNtB5_4Mode3new -FN:105,_RNvXNtCslo8MYDYmh8N_7parsing4modeNtB2_9ModeInputNtNtCs7micvSKFzzu_4core7default7Default7default -FN:172,_RNvXs3_NtCslo8MYDYmh8N_7parsing4modeNtB5_18WhenNoBindingInputINtNtB7_4util9ResolvingNtB5_13WhenNoBindingE7resolve -FN:300,_RNvXs5_NtCslo8MYDYmh8N_7parsing4modeNtB5_5ModesNtNtCs7micvSKFzzu_4core7default7Default7default -FN:247,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3new00Bb_ -FN:256,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_00Bb_ -FN:267,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s0_0Bb_ -FN:260,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s_0Bb_ -FN:244,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3new0B9_ -FN:253,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3news_0B9_ -FNDA:0,_RNvXs6_NtCslo8MYDYmh8N_7parsing4modeNtB5_9ModeInputINtNtB7_4util9ResolvingNtB5_4ModeE7resolve -FNDA:1,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3get -FNDA:13,_RNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB5_5Modes3new -FNDA:16,_RNvMsp_NtCslo8MYDYmh8N_7parsing4modeNtB5_4Mode3new -FNDA:5,_RNvXNtCslo8MYDYmh8N_7parsing4modeNtB2_9ModeInputNtNtCs7micvSKFzzu_4core7default7Default7default -FNDA:6,_RNvXs3_NtCslo8MYDYmh8N_7parsing4modeNtB5_18WhenNoBindingInputINtNtB7_4util9ResolvingNtB5_13WhenNoBindingE7resolve -FNDA:4,_RNvXs5_NtCslo8MYDYmh8N_7parsing4modeNtB5_5ModesNtNtCs7micvSKFzzu_4core7default7Default7default -FNDA:3,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3new00Bb_ -FNDA:2,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_00Bb_ -FNDA:3,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s0_0Bb_ -FNDA:6,_RNCNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB9_5Modes3news_0s_0Bb_ -FNDA:1,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3new0B9_ -FNDA:2,_RNCNvMs4_NtCslo8MYDYmh8N_7parsing4modeNtB7_5Modes3news_0B9_ -FNF:13 -FNH:12 -DA:105,5 -DA:106,5 -DA:107,5 -DA:108,5 -DA:109,5 -DA:110,5 -DA:111,5 -DA:112,5 -DA:113,5 -DA:172,6 -DA:173,6 -DA:174,0 -DA:175,5 -DA:176,1 -DA:177,0 -DA:179,6 -DA:184,16 -DA:185,16 -DA:186,7 -DA:187,7 -DA:188,2 -DA:189,1 -DA:190,1 -DA:191,5 -DA:192,9 -DA:194,15 -DA:195,15 -DA:196,15 -DA:197,15 -DA:198,15 -DA:200,16 -DA:211,13 -DA:213,13 -DA:214,13 -DA:215,13 -DA:216,33 -DA:217,22 -DA:218,0 -DA:219,22 -DA:220,22 -DA:221,22 -DA:222,1 -DA:223,21 -DA:224,21 -DA:225,13 -DA:226,1 -DA:227,1 -DA:228,12 -DA:229,12 -DA:230,8 -DA:231,20 -DA:233,11 -DA:236,1 -DA:237,10 -DA:240,10 -DA:241,10 -DA:243,10 -DA:244,10 -DA:245,1 -DA:246,1 -DA:247,3 -DA:248,1 -DA:249,1 -DA:250,10 -DA:251,10 -DA:253,2 -DA:254,2 -DA:255,2 -DA:256,2 -DA:257,2 -DA:258,2 -DA:259,8 -DA:260,6 -DA:261,5 -DA:262,5 -DA:264,2 -DA:265,1 -DA:266,1 -DA:267,3 -DA:268,1 -DA:269,1 -DA:270,0 -DA:272,1 -DA:273,1 -DA:274,1 -DA:275,2 -DA:279,10 -DA:280,25 -DA:281,16 -DA:282,16 -DA:283,16 -DA:284,16 -DA:288,9 -DA:289,9 -DA:290,9 -DA:291,9 -DA:292,13 -DA:294,1 -DA:295,1 -DA:296,1 -DA:300,4 -DA:301,4 -DA:302,4 -DA:303,4 -DA:304,4 -DA:305,4 -DA:309,0 -DA:310,0 -DA:311,0 -BRF:0 -BRH:0 -LF:114 -LH:107 -end_of_record -SF:src/rust/parsing/src/util.rs -FN:348,_RINvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB6_8RequiredpE3mapppEB8_ -FN:66,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merge0B9_ -FN:69,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merges_0B9_ -FN:36,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merge0B6_ -FN:37,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merges_0B6_ -FN:358,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE2orB7_ -FN:341,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE6as_refB7_ -FN:64,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging5mergeB7_ -FN:61,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ -FN:87,_RNvXININtCslo8MYDYmh8N_7parsing4utils2_0pEINtB5_8RequiredpENtB5_7Merging5mergeB7_ -FN:109,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging5mergeB7_ -FN:113,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging8coalesceB7_ -FN:217,_RNvXININtCslo8MYDYmh8N_7parsing4utils9_0pEINtB5_6SubsetpEINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecpEE4fromB7_ -FN:46,_RNvXININtCslo8MYDYmh8N_7parsing4utils_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ -FN:405,_RNvXININtCslo8MYDYmh8N_7parsing4utilso_0pEINtNtCsktekB2AySAD_5alloc3vec3VecpEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_6PluralpEE4fromB7_ -FN:34,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging5merge -FN:30,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging8coalesce -FN:123,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging5merge -FN:127,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging8coalesce -FN:133,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging5merge -FN:137,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging8coalesce -FN:159,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging5merge -FN:162,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging8coalesce -FN:171,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging5merge -FN:168,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging8coalesce -FN:49,_RNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueENtB4_7Merging5mergeB6_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_7Merging8coalesceB7_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEENtB5_7Merging8coalesceB7_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEENtB5_7Merging8coalesceB7_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuelEEENtB5_7Merging8coalesceB7_ -FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEENtB5_7Merging5mergeB7_ -FN:153,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_4bind10validation16BindingReferenceEENtB5_7Merging8coalesceB7_ -FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind15BindingDocInputENtB5_7Merging5mergeB7_ -FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind23CombinedBindingDocInputENtB5_7Merging5mergeB7_ -FN:143,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEEINtB5_9ResolvingINtNtB2T_3vec3VecB2P_EE7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2C_E7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEEINtB5_9ResolvingbE7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEEINtB5_9ResolvingdE7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEEINtB5_9ResolvingNtB20_13WhenNoBindingE7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode11CursorShapeEINtB5_9ResolvingB1a_E7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode13ModeHighlightEINtB5_9ResolvingB1a_E7resolveB7_ -FN:274,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionbEINtB5_9ResolvingbE7resolveB7_ -FN:286,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingIBz_B2C_EE7resolveB7_ -FN:286,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEEINtB5_9ResolvingIBz_NtNtCsbTJfyT4wEp0_4toml5value5ValueEE7resolveB7_ -FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEENtB5_7Merging8coalesceB7_ -FN:81,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FN:78,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2f_E7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingINtNtB2h_3vec3VecB2d_EE7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB20_E7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEINtB5_9ResolvingbE7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEINtB5_9ResolvingdE7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEINtB5_9ResolvingNtB1o_13WhenNoBindingE7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingB1m_E7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingB1m_E7resolveB7_ -FN:254,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolveB7_ -FN:51,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merge0B8_ -FN:52,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merges_0B8_ -FN:426,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB7_9ResolvingINtNtBR_3vec3VecBN_EE7resolve0B9_ -FN:426,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtNtB9_4bind7command12CommandInputEINtB7_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBP_7CommandEE7resolve0B9_ -FN:334,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE6unwrapB7_ -FN:334,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingE6unwrapB7_ -FN:97,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_7Merging8coalesceB7_ -FN:97,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_7Merging8coalesceB7_ -FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilbINtB5_9ResolvingbE7resolveB7_ -FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utildINtB5_9ResolvingdE7resolveB7_ -FN:313,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB2a_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ -FN:313,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB1v_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ -FN:325,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB1r_E7resolveB7_ -FN:325,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ -FN:392,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ -FN:392,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ -FN:414,_RNvXsp_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringENtNtCs7micvSKFzzu_4core7default7Default7defaultB7_ -FN:424,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingINtNtBP_3vec3VecBL_EE7resolveB7_ -FN:424,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtB5_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBN_7CommandEE7resolveB7_ -FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringINtB5_9ResolvingBy_E7resolveB7_ -FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode11CursorShapeINtB5_9ResolvingBy_E7resolveB7_ -FN:264,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode13ModeHighlightINtB5_9ResolvingBy_E7resolveB7_ -FNDA:0,_RINvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB6_8RequiredpE3mapppEB8_ -FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merge0B9_ -FNDA:0,_RNCNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB7_7Merging5merges_0B9_ -FNDA:0,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merge0B6_ -FNDA:0,_RNCNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBC_5value5ValueENtB4_7Merging5merges_0B6_ -FNDA:0,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE2orB7_ -FNDA:0,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredpE6as_refB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging5mergeB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils0_0pEINtNtCshdQd8zdVCjC_8indexmap3map8IndexMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils2_0pEINtB5_8RequiredpENtB5_7Merging5mergeB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging5mergeB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils3_0pEINtB5_6PluralpENtB5_7Merging8coalesceB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils9_0pEINtB5_6SubsetpEINtNtCs7micvSKFzzu_4core7convert4FromINtNtCsktekB2AySAD_5alloc3vec3VecpEE4fromB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utils_0pEINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringpENtB5_7Merging8coalesceB7_ -FNDA:0,_RNvXININtCslo8MYDYmh8N_7parsing4utilso_0pEINtNtCsktekB2AySAD_5alloc3vec3VecpEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_6PluralpEE4fromB7_ -FNDA:0,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging5merge -FNDA:0,_RNvXNtCslo8MYDYmh8N_7parsing4utilINtNtCsbTJfyT4wEp0_4toml3map3MapNtNtCsktekB2AySAD_5alloc6string6StringNtNtBA_5value5ValueENtB2_7Merging8coalesce -FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging5merge -FNDA:0,_RNvXs4_NtCslo8MYDYmh8N_7parsing4utilxNtB5_7Merging8coalesce -FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging5merge -FNDA:0,_RNvXs5_NtCslo8MYDYmh8N_7parsing4utilbNtB5_7Merging8coalesce -FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging5merge -FNDA:0,_RNvXs7_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringNtB5_7Merging8coalesce -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging5merge -FNDA:0,_RNvXs8_NtCslo8MYDYmh8N_7parsing4utilNtNtCsbTJfyT4wEp0_4toml5value5ValueNtB5_7Merging8coalesce -FNDA:8,_RNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB6_10expression5value5ValueENtB4_7Merging5mergeB6_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEENtB5_7Merging8coalesceB7_ -FNDA:12,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FNDA:10,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuelEEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEENtB5_7Merging5mergeB7_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_4bind10validation16BindingReferenceEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind15BindingDocInputENtB5_7Merging5mergeB7_ -FNDA:2,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4bind23CombinedBindingDocInputENtB5_7Merging5mergeB7_ -FNDA:2,_RNvXs6_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ -FNDA:1,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEEINtB5_9ResolvingINtNtB2T_3vec3VecB2P_EE7resolveB7_ -FNDA:58,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2C_E7resolveB7_ -FNDA:48,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEEINtB5_9ResolvingbE7resolveB7_ -FNDA:19,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEEINtB5_9ResolvingdE7resolveB7_ -FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEEINtB5_9ResolvingNtB20_13WhenNoBindingE7resolveB7_ -FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode11CursorShapeEINtB5_9ResolvingB1a_E7resolveB7_ -FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionNtNtB7_4mode13ModeHighlightEINtB5_9ResolvingB1a_E7resolveB7_ -FNDA:15,_RNvXsi_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionbEINtB5_9ResolvingbE7resolveB7_ -FNDA:21,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingIBz_B2C_EE7resolveB7_ -FNDA:13,_RNvXsj_NtCslo8MYDYmh8N_7parsing4utilINtNtCs7micvSKFzzu_4core6option6OptionINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEEINtB5_9ResolvingIBz_NtNtCsbTJfyT4wEp0_4toml5value5ValueEE7resolveB7_ -FNDA:6,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEENtB5_7Merging8coalesceB7_ -FNDA:12,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEENtB5_7Merging8coalesceB7_ -FNDA:2,_RNvXs1_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueENtB5_7Merging5mergeB7_ -FNDA:29,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingB2f_E7resolveB7_ -FNDA:22,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ -FNDA:47,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEEEINtB5_9ResolvingINtNtB2h_3vec3VecB2d_EE7resolveB7_ -FNDA:35,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB20_E7resolveB7_ -FNDA:3,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuebEEINtB5_9ResolvingbE7resolveB7_ -FNDA:0,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedINtNtNtB7_10expression5value10TypedValuedEEINtB5_9ResolvingdE7resolveB7_ -FNDA:6,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtB7_4mode18WhenNoBindingInputEINtB5_9ResolvingNtB1o_13WhenNoBindingE7resolveB7_ -FNDA:4,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingB1m_E7resolveB7_ -FNDA:5,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingB1m_E7resolveB7_ -FNDA:13,_RNvXsg_NtCslo8MYDYmh8N_7parsing4utilINtNtCs3c6xm2tcigH_13serde_spanned7spanned7SpannedNtNtNtB7_10expression5value5ValueEINtB5_9ResolvingNtNtCsbTJfyT4wEp0_4toml5value5ValueE7resolveB7_ -FNDA:11,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merge0B8_ -FNDA:12,_RNCNvXs_NtCslo8MYDYmh8N_7parsing4utilINtNtNtNtCsapCP8Dn5obH_3std11collections4hash3map7HashMapNtNtCsktekB2AySAD_5alloc6string6StringNtNtNtB8_10expression5value5ValueENtB6_7Merging5merges_0B8_ -FNDA:13,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB7_9ResolvingINtNtBR_3vec3VecBN_EE7resolve0B9_ -FNDA:0,_RNCNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB7_6PluralNtNtNtB9_4bind7command12CommandInputEINtB7_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBP_7CommandEE7resolve0B9_ -FNDA:3,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEE6unwrapB7_ -FNDA:3,_RNvMsm_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingE6unwrapB7_ -FNDA:6,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEENtB5_7Merging8coalesceB7_ -FNDA:6,_RNvXs2_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingENtB5_7Merging8coalesceB7_ -FNDA:13,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilbINtB5_9ResolvingbE7resolveB7_ -FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utildINtB5_9ResolvingdE7resolveB7_ -FNDA:28,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB2a_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ -FNDA:20,_RNvXsk_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtNtCs7micvSKFzzu_4core7convert7TryFromINtNtB1v_6option6OptionNtNtCsbTJfyT4wEp0_4toml5value5ValueEE8try_fromB7_ -FNDA:29,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredINtNtNtB7_10expression5value10TypedValueNtNtCsktekB2AySAD_5alloc6string6StringEEINtB5_9ResolvingB1r_E7resolveB7_ -FNDA:22,_RNvXsl_NtCslo8MYDYmh8N_7parsing4utilINtB5_8RequiredNtNtNtB7_4bind10validation10KeyBindingEINtB5_9ResolvingNtNtCsktekB2AySAD_5alloc6string6StringE7resolveB7_ -FNDA:9,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ -FNDA:0,_RNvXsn_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtNtCs7micvSKFzzu_4core7convert4FromINtB5_9RawPluralBL_EE4fromB7_ -FNDA:58,_RNvXsp_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringENtNtCs7micvSKFzzu_4core7default7Default7defaultB7_ -FNDA:46,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtCsktekB2AySAD_5alloc6string6StringEINtB5_9ResolvingINtNtBP_3vec3VecBL_EE7resolveB7_ -FNDA:0,_RNvXsq_NtCslo8MYDYmh8N_7parsing4utilINtB5_6PluralNtNtNtB7_4bind7command12CommandInputEINtB5_9ResolvingINtNtCsktekB2AySAD_5alloc3vec3VecNtBN_7CommandEE7resolveB7_ -FNDA:97,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtCsktekB2AySAD_5alloc6string6StringINtB5_9ResolvingBy_E7resolveB7_ -FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode11CursorShapeINtB5_9ResolvingBy_E7resolveB7_ -FNDA:0,_RNvXsh_NtCslo8MYDYmh8N_7parsing4utilNtNtB7_4mode13ModeHighlightINtB5_9ResolvingBy_E7resolveB7_ -FNF:44 -FNH:19 -DA:30,0 -DA:31,0 -DA:32,0 -DA:34,0 -DA:35,0 -DA:36,0 -DA:37,0 -DA:38,0 -DA:39,0 -DA:40,0 -DA:41,0 -DA:42,0 -DA:46,0 -DA:47,0 -DA:48,0 -DA:49,8 -DA:50,8 -DA:51,11 -DA:52,12 -DA:53,7 -DA:54,5 -DA:55,12 -DA:56,8 -DA:57,8 -DA:61,0 -DA:62,0 -DA:63,0 -DA:64,0 -DA:65,0 -DA:66,0 -DA:67,0 -DA:68,0 -DA:69,0 -DA:70,0 -DA:71,0 -DA:72,0 -DA:73,0 -DA:74,0 -DA:78,2 -DA:79,2 -DA:80,2 -DA:81,24 -DA:82,24 -DA:83,24 -DA:87,0 -DA:88,0 -DA:89,0 -DA:90,0 -DA:91,0 -DA:93,0 -DA:95,0 -DA:97,12 -DA:98,12 -DA:99,8 -DA:100,4 -DA:102,12 -DA:109,0 -DA:110,0 -DA:113,0 -DA:114,0 -DA:115,0 -DA:117,0 -DA:119,0 -DA:123,0 -DA:124,0 -DA:125,0 -DA:127,0 -DA:128,0 -DA:129,0 -DA:133,0 -DA:134,0 -DA:135,0 -DA:137,0 -DA:138,0 -DA:139,0 -DA:143,16 -DA:144,16 -DA:145,8 -DA:146,6 -DA:147,2 -DA:149,8 -DA:151,16 -DA:153,46 -DA:154,46 -DA:155,46 -DA:159,0 -DA:160,0 -DA:161,0 -DA:162,0 -DA:163,0 -DA:164,0 -DA:168,0 -DA:169,0 -DA:170,0 -DA:171,0 -DA:172,0 -DA:173,0 -DA:174,0 -DA:175,0 -DA:176,0 -DA:177,0 -DA:179,0 -DA:180,0 -DA:181,0 -DA:182,0 -DA:183,0 -DA:184,0 -DA:185,0 -DA:186,0 -DA:187,0 -DA:188,0 -DA:189,0 -DA:190,0 -DA:193,0 -DA:195,0 -DA:197,0 -DA:198,0 -DA:199,0 -DA:201,0 -DA:203,0 -DA:217,0 -DA:218,0 -DA:219,0 -DA:254,164 -DA:255,164 -DA:256,164 -DA:257,164 -DA:264,110 -DA:265,110 -DA:266,110 -DA:274,186 -DA:275,186 -DA:276,52 -DA:277,134 -DA:279,186 -DA:286,34 -DA:287,34 -DA:288,13 -DA:289,21 -DA:291,34 -DA:313,48 -DA:314,48 -DA:315,0 -DA:316,48 -DA:318,48 -DA:325,51 -DA:326,51 -DA:327,1 -DA:328,50 -DA:330,51 -DA:334,6 -DA:335,6 -DA:336,6 -DA:337,0 -DA:339,6 -DA:341,0 -DA:342,0 -DA:343,0 -DA:344,0 -DA:346,0 -DA:348,0 -DA:349,0 -DA:350,0 -DA:352,0 -DA:353,0 -DA:354,0 -DA:356,0 -DA:358,0 -DA:359,0 -DA:360,0 -DA:361,0 -DA:362,0 -DA:364,0 -DA:366,0 -DA:392,9 -DA:393,9 -DA:394,0 -DA:395,4 -DA:396,5 -DA:398,9 -DA:405,0 -DA:406,0 -DA:407,0 -DA:414,58 -DA:415,58 -DA:416,58 -DA:424,46 -DA:425,46 -DA:426,46 -DA:427,0 -DA:428,46 -BRF:0 -BRH:0 -LF:198 -LH:74 -end_of_record diff --git a/src/rust/parsing/coverage/parsing.profdata b/src/rust/parsing/coverage/parsing.profdata deleted file mode 100644 index ed8dff8605fdf68c1dbd85ca1c56fb02839fdce8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1288744 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𝔖MPI9R@ zxIBuX{{W6_DpZFC!i5NWn?zCIY>AMo!%%L0VTikyNrm7BbWU0F=d~ZMm0Qgrmm;AG zVNI%6Y)QZI&|hx;ky`DcHUS8XlYthmlR8?c_?NhGAlvnvAcfSXX&$xs>v-3xBHkyf;-Dm|;=oQC96bt+hHJ2qzy7i9y$Kh&8siaa zh4g4P&?>Y@*w{Di&L94RXS_Rq0z80(ES`dAo+d=#w&6}pk+Vc?Ht z3gSWOrpeN~?r&E8YtvaB(5N2F-5;w&_PscAD&zszu|-9~=DQXd7A-gr~D}B z3vX(NQ2_=W>2IU>x16wVb*rth2$xm&YjIBRd%rSrVV?4ppzd{b28?K9E&=YyOJNm7 z60|1-_g)0#D}N^}IswKWCM^X$5qDj|D=ot1)kl9G{&~_R<>>j+My2~m9`cB90MD0ytUSTkg z?Tk&N9o{63qt%wk-Udt(_DNm2vQ5>qPmJy`_z|qXP>Bv=GR2oAuYsCiQ64Hnk_MAT zL+~Ty5vc$WDDXid#1}G3=1-X$>?d19yG=K!ecFZBTzJF$U0?Ahy7Q6SL}jsnGLr## ziqxlq{|)d-jP-8F?n@>`pjlp0QZDNg5T#RtO#%*1VId^^Bxg*B_yS&6Zzz%n&kp=3 zYZ75ehH*F6HTvsR4f1C)K=IWXv19Amt{%N2d^27QyZP}cwJ^y$`46@VziWb8iu~=+ z`r(Vl%xbiJ316-#rLgYlr)(AV+I+O5kvv6K+vox}^<_X^G4cEnUq(5pj9fZo#_ugQ zwtoZFuQq%pSMm`DWzJVuf9~y4c;2!{`9~_AR=iWDexDNz7O@%YbY#|kgolEnBS9Iu zNRXzYMJ1*>dfGO+Bl+)DgZR{(zgc;-TB*0lF{j#F)Hps8)b`>xQ%o6>f@`IM45ict-FSJeNZ^xm{qOvMIaJnm@i^{o<~-lmmyRJvFWT}uKoP&y{Ylm=$x5VRv?q?%3f&Tpe75NNS(P(6 z|0}|oMtZSbXABtRC^w_dffn5cjo!*J3Wn=E@sLspFv@%- z$jk?{i9xVx?wI)|O2>%Ts(`=z3SX1 zC6)UpJ)m1Y8mo{4FY)P4CM2r04zmRYl{Nq|{)i)!VjjX}%e52=f|v-IR5RWPzuEGo zB{G1zd74g-w9fv$>$j~l$WvlnDdN~Tpi_1EQmW(EA@wM|Vq)E3dTDbs3VxL+HJtJ0 zobc*5Lb$7DBy21@{e}NsA3_?tY2xDw=k=^^c&4zy-tJvaqgscAn+SUr#SGsP;A1ra5ZN?v!KDlX48&{( zMxB*T(0}Cp(;aM;zf}c3ME;5zObBEx6@Kg#lA>R=Ic9?W4<4%aCCkpd>N?w#sJ>!l zwi&pPMd(}k;**0j+HWp5*gEBcu5neI?!w{%cOJGh5DC~~8pð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

EEh&OKBwedE|b%XalEKf)nm9XEV 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 nH5b>Z z%%S%Smd*!}2|I7+tCQJ3arNXaig?c}0@M0x(zI0{yE$q~F+bZ0TmbARyuJ$}H z*JYivD$mca4!yYs_ixsM4s`%)IfC7scPpk-V*iPt$8kUTj)=M*W2+r%_p|%psxFLg#Sa3^2E4Ks6X-q z)A)c71?P2!&g%zKpUm?9>iQkwUkKp!ev-;?KC_Trl6 z%ADI9xyxbThrVFx{_6e>lD}X8atj9Wyz>yQ<>eaEu0zrHL2$w_KBxY0uCtHe+J7Y1 zw4Ah~;Aa>ORvE){FC|TViSgA~K8NxL$HBim0lYO4w4JQZQ=iOyQ;g>)P384eGq_$N zbn}_qKQ@c&@w1_q&*46;&)&I`KOg#nAmtt|fN!}7Y_b@fumq%B%u=q&|FjH#+;U!z zT>-s!HTS8HxPA@lPHVxs>v+DzFSt*6 zndd|<`X$dle+3=;8oc=i9PyUtJ@BxUs*e@o$R44t8$;_%G@V%-qn!*T%Gq7sR^B~7WZjRO9%K} z9o6+R&hWPh)~ln=(L9;=q)06e<8ELwcb-4fl68R5;R44Xsje7ewNt;W3wcD!m9}M_I+o|)zJ8<8wBXo=)E$>q& z_`zP_ULUZYFSxu5*vSw4C`kQo{_si5d~Bc|6`<~O4pjS(4EVIX62a(u)1CLf4}ty? z%6;lfDg%0mp=tv@-+8p?o;89h(W#eIk4Dy@QGl$ z3(z+&f!!~IC$E7tPp0<`b-m3^wLj$+eA_s1zY_02z^OaJ6P%^m*>em;||Wc^FLBF))ps-C+r8T@)Fczs$*t|z93 z&YOn&7bTrG9j~7h+ARb3>6d#Z`R19Bn=e>8i@J~ciOaI8b9J-9FPj~_FGzjCx!_OE z&HHPbL;L07eulhU2jzp_mmjpX;B{Kg2LnFUO$zhAi;|AdNk1$v!uzDM$+x1YCoch- zmISYtHr_Y8Eb67pfg1(o`G)kG^5|P!0W4S%l=B%ax&KwtH>^?LUWw;=*l;b+CB3<_ zI_GW+zpcHfS5xO`PC#|kKMSs^0bQ*o*u(+M;|NmUVxbp1!Eap~{3b}b*L8Rw`3392 zPgWm1DMPsO}%)s`jbh5Wh4+-z7J7|B5DRpXNEbqu#YCn5r2#qdDl*0;Igm z_oCjn6>=@xsPl2c-`5uPBkjN@9n^VwIi%BhsPhp9{Q4b{zb`nile(Yg6U{t%?z7M% zy|`b^o9jY8(B*x(Pjf#S@Tnfq1%3Iuf)oAKb1Vb6e_3enK={3az`nttQxEWwAT94z zPxzz_@ktnRx%%?FTYs*p|JDGt|7Z~WyhFgSp***L7}sq_a82|7RhAsd=N1{ob)7L> zyN`puEtqTqbhn9M+DSZbGX=WFba40#UZ?dxHcRaXajPTw;9QQ>i{`8P8W(4!vdt_;V##dJWIf@^%To z(^}Nqtplg52TeDs`=~!L?laI|CK7WmZ07TaZsA&zwQ8Z)kEB`c9?5? zsvF`#kzZYj_vN+adX><3?cwLC24=1S=C29v5tNtL#sPKmGdgiSvo_ap&d?p}fR_b# z)`dP_kLPKw%q8{Jx$F(#mv8|eHw0(9f@>Rt^1PQ#xIf&T>n%;8Co~6Bx8!x2SGyJb zL#@?y${lZmdfE2IbCj1E)j{3Yup{?-cY?m+1>W-pLwvv?zF_9g;08g@F3|FFNt<`& z^({iXcjG?g7X`w%4FXRGgN;H#>z*Lx8}#Bje;C)48{HRvmwsSWe{jb@u<>A!@-p3r z@%ksB>x|&O+$ZZgqmh3l_;ZZ${)n-tR~W~0w}n12p8N9h64NIpqQC1Tu;3Ih`&8p| z+fL*4Cz5VHlh>~beQp-~&a-(vem&=KKV0Y*^SJ*~=-vz9cUcH_TLd0o%=3pLpskm3 ZKYqE1{BUj=`hG4q-al@I@j5N${{dprjGX`g diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 2933c65f..f4e85b29 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -174,6 +174,9 @@ pub struct BindingInput { /// impact the behavior of the keybinding, only the interactive documentation /// features describing keybindings. doc: Option, + + #[serde(flatten)] + other_fields: HashMap>, } /// @forBindingField bind @@ -240,6 +243,7 @@ impl BindingInput { repeat: self.repeat.clone(), tags: self.tags.clone(), doc: self.doc.clone(), + other_fields: self.other_fields.clone(), }; } } @@ -264,6 +268,7 @@ impl Merging for BindingInput { repeat: self.repeat.coalesce(y.repeat), tags: self.tags.coalesce(y.tags), doc: self.doc.merge(y.doc), + other_fields: y.other_fields, } } } @@ -347,6 +352,7 @@ impl Expanding for BindingInput { errors.append(&mut e.errors); None }), + other_fields: self.other_fields, }; if errors.len() > 0 { return Err(errors.into()); @@ -415,6 +421,9 @@ pub struct BindingDocInput { /// entry in the top-level `kind` array. #[serde(default)] pub kind: Option>>, + + #[serde(flatten)] + other_fields: HashMap>, } #[allow(non_snake_case)] @@ -426,6 +435,9 @@ pub struct CombinedBindingDocInput { pub key: Option>>, #[serde(default)] pub description: Option>>, + + #[serde(flatten)] + other_fields: HashMap>, } impl Merging for BindingDocInput { @@ -440,6 +452,7 @@ impl Merging for BindingDocInput { hideInDocs: self.hideInDocs.coalesce(y.hideInDocs), combined: self.combined.merge(y.combined), kind: self.kind.coalesce(y.kind), + other_fields: y.other_fields, } } } @@ -454,6 +467,7 @@ impl Merging for CombinedBindingDocInput { name: self.name.coalesce(y.name), key: self.key.coalesce(y.key), description: self.description.coalesce(y.description), + other_fields: y.other_fields, } } } @@ -501,6 +515,7 @@ impl Expanding for BindingDocInput { errors.append(&mut e.errors); None }), + other_fields: self.other_fields, }; if errors.len() > 0 { return Err(errors.into()); @@ -534,6 +549,7 @@ impl Expanding for CombinedBindingDocInput { errors.append(&mut e.errors); None }), + other_fields: self.other_fields, }; if errors.len() > 0 { return Err(errors.into()); @@ -1393,6 +1409,8 @@ mod tests { use rhai::Dynamic; use std::collections::HashMap; + use crate::file::tests::unwrap_table; + use super::*; #[test] fn complete_parsing() { @@ -1429,11 +1447,11 @@ mod tests { let args = result.args.unwrap().into_inner(); assert_eq!( - args, - Value::Table(HashMap::from([ + unwrap_table(&args), + HashMap::from([ ("a".into(), Value::String("2".into())), ("b".into(), Value::Integer(3)) - ])) + ]) ); let key: String = result.key.into_inner().unwrap().into(); assert_eq!(key, "a".to_string()); @@ -1511,8 +1529,8 @@ mod tests { "cursorMove" ); assert_eq!( - result.args.unwrap().into_inner(), - Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) + unwrap_table(&result.args.unwrap().into_inner()), + HashMap::from([("to".into(), Value::String("left".into()))]) ); let when: Option = resolve!(result, when, &mut scope).unwrap(); @@ -1548,8 +1566,8 @@ mod tests { ); assert_eq!( - left.args.unwrap().into_inner(), - Value::Table(HashMap::from([("to".into(), Value::String("left".into()))])) + unwrap_table(&left.args.unwrap().into_inner()), + HashMap::from([("to".into(), Value::String("left".into()))]) ); let prefixes: Prefix = resolve!(left, prefixes, &mut scope).unwrap(); diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index d416abfb..bbe6109a 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -55,43 +55,43 @@ pub struct CommandInput { pub skipWhen: Option>>, } -impl Expanding for CommandInput { - fn is_constant(&self) -> bool { - if self.command.is_constant() { - return false; - } - if self.args.is_constant() { - return false; - } - return true; - } - fn map_expressions(self, f: &mut F) -> ResultVec - where - F: FnMut(Expression) -> Result, - { - let mut errors = Vec::new(); - let result = CommandInput { - id: self.id, - command: self.command.map_expressions(f).unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) - }), - args: self.args.map_expressions(f).unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - None - }), - skipWhen: self.skipWhen.map_expressions(f).unwrap_or_else(|mut e| { - errors.append(&mut e.errors); - None - }), - }; - if errors.len() > 0 { - return Err(errors.into()); - } else { - return Ok(result); - } - } -} +// impl Expanding for CommandInput { +// fn is_constant(&self) -> bool { +// if self.command.is_constant() { +// return false; +// } +// if self.args.is_constant() { +// return false; +// } +// return true; +// } +// fn map_expressions(self, f: &mut F) -> ResultVec +// where +// F: FnMut(Expression) -> Result, +// { +// let mut errors = Vec::new(); +// let result = CommandInput { +// id: self.id, +// command: self.command.map_expressions(f).unwrap_or_else(|mut e| { +// errors.append(&mut e.errors); +// Spanned::new(UNKNOWN_RANGE, Required::DefaultValue) +// }), +// args: self.args.map_expressions(f).unwrap_or_else(|mut e| { +// errors.append(&mut e.errors); +// None +// }), +// skipWhen: self.skipWhen.map_expressions(f).unwrap_or_else(|mut e| { +// errors.append(&mut e.errors); +// None +// }), +// }; +// if errors.len() > 0 { +// return Err(errors.into()); +// } else { +// return Ok(result); +// } +// } +// } impl CommandInput { pub(crate) fn without_id(&self) -> Self { @@ -114,7 +114,7 @@ impl From for Value { if let Some(arg_value) = value.args { entries.insert("args".to_string(), arg_value.into_inner()); } - return Value::Table(entries); + return Value::Table(entries, None); } } @@ -176,7 +176,7 @@ pub(crate) fn regularize_commands( let commands = vec![Command { command, args: match input.args() { - None => Value::Table(HashMap::new()), + None => Value::Table(HashMap::new(), None), Some(spanned) => spanned.as_ref().clone(), }, skipWhen: input.skipWhen(), @@ -189,11 +189,15 @@ pub(crate) fn regularize_commands( .ok_or_else(|| err("`runCommands` must have `args` field"))?; let args_pos = spanned.span(); let args = spanned.as_ref().to_owned(); - let commands = match args { - Value::Table(kv) => kv - .get("commands") - .ok_or_else(|| err("`runCommands` must have `args.commands` field"))? - .clone(), + let (commands, commands_span) = match args { + Value::Table(kv, span) => { + let commands = kv + .get("commands") + .ok_or_else(|| err("`runCommands` must have `args.commands` field"))? + .clone(); + let span = span.map(|sp| sp["commands"].clone()); + (commands, span) + } _ => { return Err(err("Expected `args` to be an object with `commands` field"))?; } @@ -202,7 +206,8 @@ pub(crate) fn regularize_commands( Value::Array(items) => items, _ => { return Err(err("Expected `args.commands` of `runCommands` to \ - be a vector of commands to run."))?; + be a vector of commands to run.")) + .with_range(&commands_span)?; } }; @@ -213,13 +218,16 @@ pub(crate) fn regularize_commands( let (command, args, skipWhen) = match command { Value::String(str) => ( str.to_owned(), - Value::Table(HashMap::new()), + Value::Table(HashMap::new(), None), TypedValue::default(), ), - Value::Table(kv) => { - let result = kv.get("command").ok_or_else(|| { - err("expected `args.commands.command` field for `runCommands`") - })?; + Value::Table(kv, spans) => { + let result = kv + .get("command") + .ok_or_else(|| { + err("expected `args.commands.command` field for `runCommands`") + }) + .with_range(&commands_span)?; let command_name = match result { Value::String(x) => x.to_owned(), _ => { @@ -250,11 +258,11 @@ pub(crate) fn regularize_commands( continue; } else { let result = match kv.get("args") { - Option::None => &Value::Table(HashMap::new()), + Option::None => &Value::Table(HashMap::new(), None), Some(x) => x, }; let args = match result { - x @ Value::Table(_) => x, + x @ Value::Table(_, _) => x, x @ Value::Array(_) => x, x @ Value::Exp(_) => x, x => { @@ -272,10 +280,10 @@ pub(crate) fn regularize_commands( } x @ Value::Exp(_) => ( "runCommands".to_string(), - Value::Table(HashMap::from([( - "commands".to_string(), - Value::Array(vec![x]), - )])), + Value::Table( + HashMap::from([("commands".to_string(), Value::Array(vec![x]))]), + None, + ), TypedValue::Constant(false), ), _ => { @@ -325,7 +333,7 @@ impl Command { command: resolve!(input, command, scope)?, args: match input.args { Some(x) => x.into_inner(), - Option::None => Value::Table(HashMap::new()), + Option::None => Value::Table(HashMap::new(), None), }, skipWhen: resolve!(input, skipWhen, scope)?, }); @@ -353,7 +361,7 @@ impl Expanding for Command { command: self.command, args: self.args.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); - Value::Table(HashMap::new()) + Value::Table(HashMap::new(), None) }), skipWhen: self.skipWhen.map_expressions(f).unwrap_or_else(|mut e| { errors.append(&mut e.errors); @@ -372,6 +380,7 @@ impl Expanding for Command { #[cfg(test)] mod tests { use crate::bind::command::regularize_commands; + use crate::file::tests::unwrap_table; use test_log::test; use super::*; @@ -402,13 +411,13 @@ mod tests { assert_eq!(commands[1].command, "b"); assert_eq!(commands[2].command, "c"); - assert_eq!(commands[0].args, Value::Table(HashMap::new())); + assert_eq!(commands[0].args, Value::Table(HashMap::new(), None)); assert_eq!( - commands[1].args, - Value::Table(HashMap::from([ + unwrap_table(&commands[1].args), + HashMap::from([ ("foo".to_string(), Value::Integer(1)), ("bar".to_string(), Value::Integer(2)), - ])) + ]) ); assert_eq!( commands[2].args, diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 98662fc8..471d75ab 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -300,9 +300,7 @@ impl BindingInput { pub fn expand_foreach(self, scope: &mut Scope) -> ResultVec> { if self.has_foreach() { let foreach = expand_keys(self.foreach.clone().unwrap(), scope)?; - foreach.require_constant().with_message( - "`foreach` values can only include expressions of the form {{keys(`regex`)}}", - )?; + foreach.require_constant()?; let values = expand_foreach_values(foreach).into_iter().map(|values| { let mut result = self.clone(); diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index c74a93e6..920f5b0e 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -310,11 +310,21 @@ impl Define { } mod tests { + use test_log::test; + #[allow(unused_imports)] use super::*; #[allow(unused_imports)] use crate::resolve; + #[allow(dead_code)] + fn unwrap_table(x: &Value) -> HashMap { + match x { + Value::Table(x, _) => x.clone(), + _ => panic!("Expected a table!"), + } + } + #[test] fn simple_parsing() { let data = r#" @@ -346,11 +356,11 @@ mod tests { assert_eq!(foo.key.as_ref().to_owned().unwrap().unwrap(), "x"); let args = foo.args.as_ref().unwrap().clone().into_inner(); assert_eq!( - args, - Value::Table(HashMap::from([ + unwrap_table(&args), + HashMap::from([ ("k".into(), Value::Integer(1)), ("h".into(), Value::Integer(2)) - ])) + ]) ); let foobar = result.command.get("foobar").unwrap(); @@ -358,14 +368,14 @@ mod tests { assert_eq!(command, "runCommands"); let commands = foobar.args.as_ref().unwrap().clone().into_inner(); assert_eq!( - commands, - Value::Table(HashMap::from([( + unwrap_table(&commands), + HashMap::from([( "commands".into(), Value::Array(vec![ Value::String("foo".into()), Value::String("bar".into()) ]) - )])) + )]) ); } } diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 9e2f4b8f..1e324b09 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -110,6 +110,7 @@ pub enum ErrorLevel { pub enum Context { Message(String), // additional message content to include Range(Range), // the location of an error in a file + ExpRange(Range), // location of expression being evaluated (can be merged with a rhai::Position) RefRange(Range), // another location mentioned in the error message } @@ -137,6 +138,12 @@ impl Spannable for Range { } } +impl Spannable for Option> { + fn range(&self) -> Option> { + return self.clone(); + } +} + impl Spannable for &Range { fn range(&self) -> Option> { return Some(self.to_owned().clone()); @@ -164,6 +171,13 @@ where return self.with_context(Context::Range(UNKNOWN_RANGE)); } } + fn with_exp_range(self, context: &impl Spannable) -> std::result::Result { + if let Some(range) = context.range() { + return self.with_context(Context::ExpRange(range)); + } else { + return self.with_context(Context::Range(UNKNOWN_RANGE)); + } + } fn with_ref_range(self, context: &impl Spannable) -> std::result::Result { if let Some(range) = context.range() { return self.with_context(Context::RefRange(range)); @@ -202,9 +216,9 @@ impl> From for ParseError { } } -impl From> for ParseError { - fn from(value: Box) -> ParseError { - return RawError::Dynamic(value.to_string()).into(); +impl From> for RawError { + fn from(value: Box) -> RawError { + return RawError::Dynamic(value.to_string()); } } @@ -313,6 +327,9 @@ impl fmt::Display for ParseError { Context::Range(range) => { write!(f, "byte range {:?}\n", range)?; } + Context::ExpRange(range) => { + write!(f, "byte range {:?}\n", range)?; + } Context::RefRange(range) => { write!(f, "and byte range {:?}\n", range)?; } @@ -392,16 +409,23 @@ impl ParseError { // range if range.contains(&new_range.start) && range.contains(&new_range.end) { range = new_range.clone(); - let new_char_line_range = range_to_pos(&new_range, &offsets); - if let Some(pos) = rhai_pos { - char_line_range = Some(resolve_rhai_pos_from_expression_range( - pos, - new_char_line_range, - )); - rhai_pos = None; - } else { - char_line_range = Some(new_char_line_range); - } + char_line_range = Some(range_to_pos(&new_range, &offsets)); + } + } + Context::ExpRange(new_range) => { + // a range reported via ExpRange is one that specifically matches the + // span of an expression, and so we know its safe to merge it with the + // position reported by a rhai position + range = new_range.clone(); + let new_char_line_range = range_to_pos(&new_range, &offsets); + if let Some(pos) = rhai_pos { + char_line_range = Some(resolve_rhai_pos_from_expression_range( + pos, + new_char_line_range, + )); + rhai_pos = None; + } else { + char_line_range = Some(new_char_line_range); } } Context::RefRange(new_range) => { diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 0c1797d7..487d9af9 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -147,10 +147,15 @@ impl Scope { let val: Dynamic = From::::from(Value::new(v.clone(), None)?); self.state.push_dynamic(k, val); } - let dynamic: rhai::Dynamic = self.engine.eval_ast_with_scope(&mut self.state, ast)?; + let dynamic: Dynamic = self + .engine + .eval_ast_with_scope(&mut self.state, ast) + .with_exp_range(&expr.span)?; self.state.rewind(rewind_to); let result_value: std::result::Result = dynamic.clone().try_into(); - let value = result_value.with_message(format!(" while evaluating:\n{expr}"))?; + let value = result_value + .with_message(format!(" while evaluating:\n{expr}")) + .with_exp_range(&expr.span)?; return Ok(value); })?); } @@ -163,7 +168,7 @@ impl Scope { let ast = self .engine .compile_expression(expr.content.clone()) - .with_range(&expr.span)?; + .with_exp_range(&expr.span)?; self.asts.insert(expr.content.clone(), ast); return Ok(Value::Exp(expr)); })?; @@ -347,6 +352,40 @@ mod tests { assert!(message.contains("unexpected `")); } + #[test] + fn expression_bracket_error_5() { + let data = r#" + joe = "{{joe.bob}}.{{bill.bob}}.fob{{" + "#; + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + info!("report: {report:#?}"); + assert!(message.contains("unexpected `{{`")); + } + + #[test] + fn expression_bracket_error_6() { + let data = r#" + joe = "{{joe.bob}}.{{bill.bob}}.fob{{" + "#; + let value: Value = toml::from_str(data).unwrap(); + let mut scope = Scope::new(); + let err = scope.parse_asts(&value).unwrap_err(); + + let report = err.report(data.as_bytes()); + let message = report.first().unwrap().message.clone(); + let range = report.first().unwrap().range.clone(); + let val: String = data[(range.start.col)..=(range.end.col)].to_string(); + info!("report: {report:#?}"); + assert!(message.contains("unexpected `{{`")); + } + #[test] fn clean_expression_error_locations() { let data = r#" diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 5b2448ee..2a0d3a1d 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -36,7 +36,10 @@ pub enum Value { String(String), Boolean(bool), Array(Vec), - Table(HashMap), + Table( + HashMap, + Option>>, + ), Interp(Vec), Exp(Expression), } @@ -256,11 +259,15 @@ impl Value { Value::Array(values.collect::>()?) } BareValue::Table(toml_kv) => { + let k_span = toml_kv + .iter() + .map(|(k, v)| (k.clone(), v.span().clone())) + .collect(); let kv = toml_kv.into_iter().map(|(k, v)| { let span = v.span(); return Ok((k, Value::new(v.into_inner(), Some(span))?)); }); - Value::Table(kv.collect::>()?) + Value::Table(kv.collect::>()?, Some(k_span)) } }); } @@ -431,7 +438,17 @@ impl From for BareValue { let new_items = items.into_iter().map(|it| it.into()).collect(); BareValue::Array(new_items) } - Value::Table(kv) => { + Value::Table(kv, Some(k_spans)) => { + let new_kv = kv + .into_iter() + .map(|(k, v)| { + let span = k_spans[&k].clone(); + return (k, Spanned::new(span, v.into())); + }) + .collect(); + BareValue::Table(new_kv) + } + Value::Table(kv, Option::None) => { let new_kv = kv .into_iter() .map(|(k, v)| (k, Spanned::new(UNKNOWN_RANGE, v.into()))) @@ -457,7 +474,7 @@ impl From for toml::Value { let new_items = items.into_iter().map(|it| it.into()).collect(); toml::Value::Array(new_items) } - Value::Table(kv) => { + Value::Table(kv, _) => { let new_kv = kv.into_iter().map(|(k, v)| (k, v.into())).collect(); toml::Value::Table(new_kv) } @@ -480,7 +497,7 @@ impl From for Dynamic { let elements: Vec = x.into_iter().map(|x| Dynamic::from(x)).collect(); elements.into() } - Value::Table(x) => { + Value::Table(x, _) => { let map: std::collections::HashMap = x.into_iter().map(|(k, v)| (k, v.into())).collect(); map.into() @@ -514,7 +531,7 @@ impl TryFrom for Value { .into_iter() .map(|(k, v)| Ok((k.as_str().to_string(), Value::try_from(v.to_owned())?))) .collect::>>()?; - return Ok(Value::Table(values)); + return Ok(Value::Table(values, None)); } else if value.is_bool() { return Ok(Value::Boolean(value.as_bool().expect("boolean"))); } else if value.is_float() { @@ -545,7 +562,7 @@ impl TryFrom for Value { impl Default for Value { fn default() -> Self { - return Value::Table(HashMap::new()); + return Value::Table(HashMap::new(), None); } } @@ -572,9 +589,11 @@ impl Merging for Value { } _ => Value::Array(new_values), }, - Value::Table(new_kv) => match self { - Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), - _ => Value::Table(new_kv), + Value::Table(new_kv, new_spans) => match self { + Value::Table(old_kv, old_spans) => { + Value::Table(old_kv.merge(new_kv), old_spans.merge(new_spans)) + } + _ => Value::Table(new_kv, new_spans), }, _ => new, } @@ -669,7 +688,7 @@ impl Expanding for Value { Value::Exp(Expression { .. }) => false, Value::Interp(_) => false, Value::Array(items) => items.iter().all(|it| it.is_constant()), - Value::Table(kv) => kv.values().all(|it| it.is_constant()), + Value::Table(kv, _) => kv.values().all(|it| it.is_constant()), Value::Boolean(_) | Value::Float(_) | Value::Integer(_) | Value::String(_) => true, } } @@ -697,7 +716,16 @@ impl Expanding for Value { } } Value::Array(items) => Value::Array(items.map_expressions(f)?), - Value::Table(kv) => Value::Table(kv.map_expressions(f)?), + Value::Table(kv, Some(spans)) => { + let kv = flatten_errors(kv.into_iter().map(|(k, v)| { + let span = spans[&k].clone(); + return Ok((k, v.map_expressions(f).with_range(&span)?)); + }))? + .into_iter() + .collect(); + Value::Table(kv, Some(spans)) + } + Value::Table(kv, Option::None) => Value::Table(kv.map_expressions(f)?, None), literal @ (Value::Boolean(_) | Value::Float(_) | Value::Integer(_) @@ -986,6 +1014,8 @@ impl Merging for TypedValue { } mod tests { + use test_log::test; + #[allow(unused_imports)] use super::*; @@ -997,4 +1027,54 @@ mod tests { let value: std::result::Result = toml::from_str(data); assert!(value.is_ok()); } + + #[test] + fn parse_large_number() { + let data = r#" + number = 5_000_000_000 + "#; + let err: std::result::Result = toml::from_str(data); + assert!( + err.unwrap_err() + .to_string() + .contains("i64 value was too large") + ); + } + + #[test] + fn parse_duplicate_key() { + let data = r#" + a = 1 + b = 2 + a = 3 + "#; + let err: std::result::Result = toml::from_str(data); + assert!(err.unwrap_err().to_string().contains("duplicate key")); + } + + #[test] + #[should_panic] + fn unresolved_expression_panics() { + let data = r#" + value = '{{1+2}}' + "#; + let value: std::result::Result = toml::from_str(data); + match value { + Ok(x) => BareValue::from(x), + Err(_) => return, + }; + } + + #[test] + #[should_panic] + fn unresolved_interp_panics() { + let data = r#" + value = 'joe {{1+2}} bob' + "#; + let value: std::result::Result = toml::from_str(data); + match value { + Ok(x) => BareValue::from(x), + Err(_) => return, + }; + } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index a394a2c3..d4e9b6c1 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -301,6 +301,8 @@ pub struct KeyFileResult { pub errors: Option>, } +// LCOV_EXCL_START +// These lines are tested during integration tests with the typescript code #[wasm_bindgen] pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { return match parse_bytes_helper(&file_content) { @@ -320,6 +322,7 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { }, }; } +// LCOV_EXCL_STOP fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { // ensure there's a directive @@ -439,7 +442,7 @@ pub fn identify_legacy_warnings(file_content: Box<[u8]>) -> KeyFileResult { } #[cfg(test)] -mod tests { +pub(crate) mod tests { use super::*; use crate::bind::BindingOutputArgs; use crate::bind::UNKNOWN_RANGE; @@ -450,6 +453,13 @@ mod tests { use std::collections::HashMap; use test_log::test; + pub(crate) fn unwrap_table(x: &Value) -> HashMap { + match x { + Value::Table(x, _) => x.clone(), + _ => panic!("Expected a table!"), + } + } + #[test] fn parse_example() { let data = r#" @@ -472,7 +482,7 @@ mod tests { [[bind]] key = "h" - model = "normal" + mode = "normal" command = "cursorLeft" "#; @@ -555,8 +565,8 @@ mod tests { assert_eq!(result.bind[0].key[0], "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( - result.bind[0].commands[0].args, - Value::Table(HashMap::from([ + unwrap_table(&result.bind[0].commands[0].args), + HashMap::from([ ("a".into(), Value::Integer(1)), ( "b".into(), @@ -567,7 +577,7 @@ mod tests { scope: SmallVec::new(), }) ), - ])) + ]) ); assert_eq!(result.bind[0].commands[1].command, "bar"); } @@ -609,8 +619,8 @@ mod tests { assert_eq!(result.bind[0].key[0], "a"); assert_eq!(result.bind[0].commands[0].command, "shebang"); assert_eq!( - result.bind[0].commands[0].args, - Value::Table(HashMap::from([ + unwrap_table(&result.bind[0].commands[0].args), + HashMap::from([ ("a".into(), Value::Integer(1)), ( "b".into(), @@ -621,7 +631,7 @@ mod tests { scope: SmallVec::new(), }) ), - ])) + ]) ); assert_eq!(result.bind[0].commands[1].command, "bar"); } @@ -1309,6 +1319,52 @@ mod tests { assert_eq!(report[0].range.start.line, 16); } + #[test] + fn expression_error_resolves_to_field_in_array() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "foobar" + args.names = ["{{1+2}}", "{{(1+2}}"] + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("Expecting ')'")); + assert_eq!(report[0].range.start.line, 7); + assert_eq!(report[0].range.end.line, 7); + assert_eq!(report[0].range.start.col, 21); + assert_eq!(report[0].range.end.col, 44); + } + + #[test] + fn unmatched_bracket_error_resolves_to_field_in_array() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "foobar" + args.names = ["{{1+2}}", "{{1+2"] + "#; + + let mut scope = Scope::new(); + let err = + KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("unexpected `{{`")); + assert_eq!(report[0].range.start.line, 7); + assert_eq!(report[0].range.end.line, 7); + assert_eq!(report[0].range.start.col, 21); + assert_eq!(report[0].range.end.col, 41); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 79c098a6..0a62dcbc 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -6,6 +6,7 @@ use serde::{Deserialize, Serialize}; use std::collections::HashMap; use toml::{Spanned, Value}; +use crate::bind::UNKNOWN_RANGE; use crate::err; use crate::error::{ErrorContext, ParseError, Result, ResultVec, flatten_errors}; use crate::expression::Scope; @@ -83,6 +84,23 @@ impl Merging for Spanned { } } +impl Merging for core::ops::Range { + fn merge(self, new: Self) -> Self { + if new != UNKNOWN_RANGE { + return new; + } else { + return self; + } + } + fn coalesce(self, new: Self) -> Self { + if new != UNKNOWN_RANGE { + return new; + } else { + return self; + } + } +} + impl Merging for Required { fn merge(self, new: Self) -> Self { return match new { @@ -337,33 +355,6 @@ impl Required { Required::DefaultValue => panic!("Required value missing"), }; } - - pub fn as_ref(&self) -> Required<&T> { - match *self { - Required::Value(ref x) => Required::Value(x), - Required::DefaultValue => Required::DefaultValue, - } - } - - pub fn map(self, f: F) -> Required - where - F: Fn(T) -> R, - { - match self { - Required::DefaultValue => Required::DefaultValue, - Required::Value(x) => Required::Value(f(x)), - } - } - - pub fn or(self, new: Self) -> Self { - return match new { - Required::Value(new_val) => match self { - Required::DefaultValue => Required::Value(new_val), - _ => self, - }, - Required::DefaultValue => self, - }; - } } // From 8170c5bb426fc89207d48dc1e1142094dc5f4f24 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 15 Oct 2025 13:34:15 -0400 Subject: [PATCH 74/79] fixed some tests, added check for `keys` regex error Created using spr 1.3.6-beta.1 --- .vscode/extensions.json | 1 + .vscode/settings.json | 34 +- mise.toml | 1 - notes.md | 20 +- .../CPU-20251014T121114.750Z.cpuprofile.txt | 93047 ++++++++++++++++ src/rust/parsing/src/bind.rs | 117 +- src/rust/parsing/src/bind/foreach.rs | 6 - src/rust/parsing/src/define.rs | 35 +- src/rust/parsing/src/error.rs | 6 +- src/rust/parsing/src/expression.rs | 5 +- src/rust/parsing/src/expression/value.rs | 18 +- src/rust/parsing/src/file.rs | 370 +- src/rust/parsing/src/kind.rs | 17 +- src/rust/parsing/src/mode.rs | 43 +- 14 files changed, 93551 insertions(+), 169 deletions(-) create mode 100644 src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt diff --git a/.vscode/extensions.json b/.vscode/extensions.json index 95354a43..a45c1472 100644 --- a/.vscode/extensions.json +++ b/.vscode/extensions.json @@ -7,5 +7,6 @@ "ms-vscode.extension-test-runner", "ms-playwright.playwright", "rust-lang.rust-analyzer", + "hverlin.mise-vscode", ] } diff --git a/.vscode/settings.json b/.vscode/settings.json index 1ef1db9d..39d2d447 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -9,28 +9,26 @@ "src/rust/parsing/Cargo.toml" ], "window.title": "vscode-master-key", - "rust-analyzer.cargo.sysroot": "/Users/davidlittle/.rustup/toolchains/1.90.0-aarch64-apple-darwin", - "rust-analyzer.cargo.sysrootSrc": "/Users/davidlittle/.rustup/toolchains/1.90.0-aarch64-apple-darwin/lib/rustlib/src/rust", + // NOTE: if we update the version of rust used in `mise.toml.` these + // paths also need to be updated + "rust-analyzer.cargo.sysroot": "${userHome}/.rustup/toolchains/1.90.0-aarch64-apple-darwin", + "rust-analyzer.cargo.sysrootSrc": "${userHome}/.rustup/toolchains/1.90.0-aarch64-apple-darwin/lib/rustlib/src/rust", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, "workbench.colorCustomizations": { - "editorBracketHighlight.foreground1": "#1b9e77", - "editorBracketHighlight.foreground2": "#d95f02", - "editorBracketHighlight.foreground3": "#7570b3", - "editorBracketHighlight.foreground4": "#e7298a", - "editorBracketHighlight.foreground5": "#66a61e", - "editorBracketHighlight.foreground6": "#e6ab02", - "editorBracketHighlight.unexpectedBracket.foreground": "#ff0000", - "titleBar.activeBackground": "#f46558", - "titleBar.activeForeground": "#000000", - "titleBar.inactiveBackground": "#f46558", - "titleBar.inactiveForeground": "#000000", - "titleBar.border": "#f46558", - "activityBar.foreground": "#f46558", - "tab.activeBorder": "#f46558", - "iLoveWorkSpaceColors": true, + "iLoveWorkSpaceColors": false, "iLoveWorkSpaceRandom": false, - "useWorkspaceLite": true + "useWorkspaceLite": false }, + "debug.javascript.defaultRuntimeExecutable": { + "pwa-node": "/Users/davidlittle/.local/share/mise/shims/node" + }, + "files.watcherExclude": { + "**/.git/**": true, + "**/.jj/**": true, + "**/target/**": true, + "out/**": true, + }, + "python.defaultInterpreterPath": "${userHome}/.local/share/mise/installs/python/3.10.4/bin/python", } diff --git a/mise.toml b/mise.toml index 3b37e6ac..b8a2ba78 100644 --- a/mise.toml +++ b/mise.toml @@ -41,7 +41,6 @@ run = [ [vars] coverage_options = '''--ignore-filename-regex '/.cargo/registry' --ignore-filename-regex '.rustup/toolchains' --ignore-filename-regex 'rustc/' --compilation-dir src/rust/parsing --instr-profile coverage/parsing.profdata --Xdemangler rustfilt''' -# TODO: generate an lcov report I can merge with the other coverage output [tasks.test-rust] dir = 'src/rust/parsing' shell = 'nu -c' diff --git a/notes.md b/notes.md index be4e4229..51fa831a 100644 --- a/notes.md +++ b/notes.md @@ -259,18 +259,29 @@ Integration test debugging: - NOTE: these come from the line and char position in the rhai expression which has nothing to do with the line and char position in the parent keybinding file - - [ ] list of errors to check on + - [ ] list of individual errors to check on - [X] parsing a number that's too large - [X] duplicate toml key - [X] unmatched `{{` when there are other matches braces before it - [X] expression error for expression in an array - [X] unmatched `{{` when child of array - [X] unresolved expression (and interpolation) in conversion of Value -> BareValue - - [ ] warn about unexpected fields in `[[bind]]` (and others) - - [ ] invalid regex for `keys` function + - [X] warn about unexpected fields in `[[bind]]` (and others) + - [X] fix failing tests + - [X] for `[[bind]]` + - [X] for `[[kind]]` + - [X] for `[[mode]]` + - [X] for `[[define]]` + - [X] setup a system for passing warnings up through call stacks + while still returning a result + - [X] using `warnings` args + - [X] how do we handle `resolve`? place in `&mut Scope`? + or maybe we should create an object that contains scope + and pass that to resolve because the name is starting to be misleading + - [X] invalid regex for `keys` function - [ ] invalid keybinding strings (modifier and key) - [ ] layout invariant binding works - - [ ] expression evaluating to non-string value for `key` fieldd + - [ ] expression evaluating to non-string value for `key` field - [ ] unresolved expressions when converting from Value -> toml::Value - [ ] errors in an expression of a `[[bind]]` field point to the field - [ ] for top-level @@ -297,6 +308,7 @@ Integration test debugging: - [ ] test that all error messages show up when expected - [ ] make sure a range is always provided - [ ] integration test for both warnings and errors in type script setup + - [ ] validate modes to ensure that at least one allows the user to type 😬 - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) diff --git a/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt b/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt new file mode 100644 index 00000000..2c0c1817 --- /dev/null +++ b/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt @@ -0,0 +1,93047 @@ +{ + "nodes": [ + { + "id": 1, + "callFrame": { + "functionName": "(root)", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 0, + "children": [ + 2, + 3, + 8, + 9, + 10, + 61, + 72, + 92, + 115, + 123, + 139, + 142, + 148, + 170, + 172, + 175, + 215, + 217, + 246, + 255, + 276, + 291, + 314, + 317, + 327, + 334, + 337, + 346, + 347, + 354, + 355, + 394, + 397, + 398, + 423, + 426, + 428, + 470, + 473, + 504, + 510, + 546, + 557, + 563, + 564, + 579, + 590, + 595, + 599, + 641, + 708, + 712, + 717, + 758 + ] + }, + { + "id": 2, + "callFrame": { + "functionName": "(program)", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1060 + }, + { + "id": 3, + "callFrame": { + "functionName": "r", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 239, + "columnNumber": 935 + }, + "hitCount": 219, + "children": [ + 4, + 486 + ], + "positionTicks": [ + { + "line": 240, + "ticks": 22 + }, + { + "line": 240, + "ticks": 135 + }, + { + "line": 240, + "ticks": 1 + }, + { + "line": 240, + "ticks": 61 + } + ] + }, + { + "id": 4, + "callFrame": { + "functionName": "re", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8649 + }, + "hitCount": 267, + "children": [ + 5 + ], + "positionTicks": [ + { + "line": 222, + "ticks": 4 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 2 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 28, + "ticks": 4 + }, + { + "line": 228, + "ticks": 3 + }, + { + "line": 222, + "ticks": 5 + }, + { + "line": 222, + "ticks": 2 + }, + { + "line": 228, + "ticks": 3 + }, + { + "line": 222, + "ticks": 6 + }, + { + "line": 222, + "ticks": 11 + }, + { + "line": 222, + "ticks": 26 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 18 + }, + { + "line": 222, + "ticks": 10 + }, + { + "line": 222, + "ticks": 4 + }, + { + "line": 228, + "ticks": 9 + }, + { + "line": 228, + "ticks": 9 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 10 + }, + { + "line": 222, + "ticks": 7 + }, + { + "line": 222, + "ticks": 15 + }, + { + "line": 222, + "ticks": 8 + }, + { + "line": 222, + "ticks": 6 + }, + { + "line": 28, + "ticks": 10 + }, + { + "line": 222, + "ticks": 5 + }, + { + "line": 222, + "ticks": 15 + }, + { + "line": 222, + "ticks": 47 + }, + { + "line": 222, + "ticks": 13 + } + ] + }, + { + "id": 5, + "callFrame": { + "functionName": "parse", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 21964 + }, + "hitCount": 2157, + "children": [ + 6, + 7 + ], + "positionTicks": [ + { + "line": 222, + "ticks": 2 + }, + { + "line": 222, + "ticks": 2155 + } + ] + }, + { + "id": 6, + "callFrame": { + "functionName": "ko", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 24025 + }, + "hitCount": 1849, + "positionTicks": [ + { + "line": 222, + "ticks": 1849 + } + ] + }, + { + "id": 7, + "callFrame": { + "functionName": "Bc", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 20641 + }, + "hitCount": 640, + "positionTicks": [ + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 5 + }, + { + "line": 222, + "ticks": 6 + }, + { + "line": 222, + "ticks": 4 + }, + { + "line": 222, + "ticks": 2 + }, + { + "line": 222, + "ticks": 17 + }, + { + "line": 222, + "ticks": 7 + }, + { + "line": 222, + "ticks": 483 + }, + { + "line": 222, + "ticks": 33 + }, + { + "line": 222, + "ticks": 3 + }, + { + "line": 222, + "ticks": 19 + }, + { + "line": 222, + "ticks": 15 + }, + { + "line": 222, + "ticks": 2 + }, + { + "line": 222, + "ticks": 24 + }, + { + "line": 222, + "ticks": 5 + }, + { + "line": 222, + "ticks": 12 + } + ] + }, + { + "id": 486, + "callFrame": { + "functionName": "Bc", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 20641 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 222, + "ticks": 1 + } + ] + }, + { + "id": 8, + "callFrame": { + "functionName": "refresh", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 234, + "columnNumber": 875 + }, + "hitCount": 121, + "children": [ + 171 + ], + "positionTicks": [ + { + "line": 235, + "ticks": 121 + } + ] + }, + { + "id": 171, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 234, + "columnNumber": 918 + }, + "hitCount": 17, + "positionTicks": [ + { + "line": 235, + "ticks": 1 + }, + { + "line": 235, + "ticks": 6 + }, + { + "line": 235, + "ticks": 10 + } + ] + }, + { + "id": 9, + "callFrame": { + "functionName": "(idle)", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 8172 + }, + { + "id": 10, + "callFrame": { + "functionName": "onStreamRead", + "scriptId": "113", + "url": "node:internal/stream_base_commons", + "lineNumber": 165, + "columnNumber": 21 + }, + "hitCount": 13, + "children": [ + 11, + 19, + 500, + 544, + 547, + 549, + 558, + 580, + 644 + ], + "positionTicks": [ + { + "line": 166, + "ticks": 13 + } + ] + }, + { + "id": 11, + "callFrame": { + "functionName": "Readable.push", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 386, + "columnNumber": 34 + }, + "hitCount": 0, + "children": [ + 12 + ] + }, + { + "id": 12, + "callFrame": { + "functionName": "readableAddChunkPushByteMode", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 462, + "columnNumber": 37 + }, + "hitCount": 0, + "children": [ + 13 + ] + }, + { + "id": 13, + "callFrame": { + "functionName": "onEofChunk", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 787, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 14 + ] + }, + { + "id": 14, + "callFrame": { + "functionName": "emitReadable_", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 829, + "columnNumber": 22 + }, + "hitCount": 0, + "children": [ + 15 + ] + }, + { + "id": 15, + "callFrame": { + "functionName": "Socket.read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 779, + "columnNumber": 32 + }, + "hitCount": 0, + "children": [ + 16 + ] + }, + { + "id": 16, + "callFrame": { + "functionName": "Readable.read", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 646, + "columnNumber": 34 + }, + "hitCount": 0, + "children": [ + 17 + ] + }, + { + "id": 17, + "callFrame": { + "functionName": "endReadable", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1681, + "columnNumber": 20 + }, + "hitCount": 0, + "children": [ + 18 + ] + }, + { + "id": 18, + "callFrame": { + "functionName": "nextTick", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 112, + "columnNumber": 17 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 139, + "ticks": 1 + }, + { + "line": 137, + "ticks": 1 + }, + { + "line": 135, + "ticks": 1 + } + ] + }, + { + "id": 19, + "callFrame": { + "functionName": "readableAddChunkPushByteMode", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 462, + "columnNumber": 37 + }, + "hitCount": 5, + "children": [ + 20, + 645 + ], + "positionTicks": [ + { + "line": 530, + "ticks": 2 + }, + { + "line": 477, + "ticks": 3 + } + ] + }, + { + "id": 20, + "callFrame": { + "functionName": "addChunk", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 549, + "columnNumber": 17 + }, + "hitCount": 0, + "children": [ + 21, + 311 + ] + }, + { + "id": 21, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 1, + "children": [ + 22, + 391, + 731 + ], + "positionTicks": [ + { + "line": 519, + "ticks": 1 + } + ] + }, + { + "id": 22, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 1152 + }, + "hitCount": 71, + "children": [ + 23, + 377 + ], + "positionTicks": [ + { + "line": 136, + "ticks": 71 + } + ] + }, + { + "id": 23, + "callFrame": { + "functionName": "s", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 703 + }, + "hitCount": 31, + "children": [ + 24, + 551, + 584 + ], + "positionTicks": [ + { + "line": 136, + "ticks": 31 + } + ] + }, + { + "id": 24, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 133, + "columnNumber": 107 + }, + "hitCount": 1715, + "children": [ + 25, + 30 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 136, + "ticks": 1 + }, + { + "line": 135, + "ticks": 5 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 136, + "ticks": 2 + }, + { + "line": 136, + "ticks": 2 + }, + { + "line": 136, + "ticks": 1 + }, + { + "line": 136, + "ticks": 3 + }, + { + "line": 136, + "ticks": 4 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 224 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 136, + "ticks": 1 + }, + { + "line": 142, + "ticks": 3 + }, + { + "line": 136, + "ticks": 3 + }, + { + "line": 136, + "ticks": 3 + }, + { + "line": 136, + "ticks": 10 + }, + { + "line": 142, + "ticks": 21 + }, + { + "line": 136, + "ticks": 9 + }, + { + "line": 134, + "ticks": 3 + }, + { + "line": 136, + "ticks": 6 + }, + { + "line": 142, + "ticks": 21 + }, + { + "line": 142, + "ticks": 9 + }, + { + "line": 136, + "ticks": 14 + }, + { + "line": 27, + "ticks": 78 + }, + { + "line": 27, + "ticks": 224 + }, + { + "line": 27, + "ticks": 66 + }, + { + "line": 136, + "ticks": 8 + }, + { + "line": 27, + "ticks": 829 + }, + { + "line": 142, + "ticks": 4 + }, + { + "line": 142, + "ticks": 4 + }, + { + "line": 142, + "ticks": 1 + }, + { + "line": 27, + "ticks": 4 + }, + { + "line": 136, + "ticks": 7 + }, + { + "line": 142, + "ticks": 13 + }, + { + "line": 142, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 134, + "ticks": 1 + }, + { + "line": 134, + "ticks": 121 + } + ] + }, + { + "id": 25, + "callFrame": { + "functionName": "Md", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 91870 + }, + "hitCount": 0, + "children": [ + 26 + ] + }, + { + "id": 26, + "callFrame": { + "functionName": "JS", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 91989 + }, + "hitCount": 539, + "children": [ + 27, + 64 + ], + "positionTicks": [ + { + "line": 8, + "ticks": 1 + }, + { + "line": 8, + "ticks": 1 + }, + { + "line": 8, + "ticks": 1 + }, + { + "line": 28, + "ticks": 536 + } + ] + }, + { + "id": 27, + "callFrame": { + "functionName": "set", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9960 + }, + "hitCount": 0, + "children": [ + 28, + 69 + ] + }, + { + "id": 28, + "callFrame": { + "functionName": "set", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9799 + }, + "hitCount": 0, + "children": [ + 29 + ] + }, + { + "id": 29, + "callFrame": { + "functionName": "set", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 6305 + }, + "hitCount": 12, + "positionTicks": [ + { + "line": 8, + "ticks": 5 + }, + { + "line": 8, + "ticks": 7 + } + ] + }, + { + "id": 69, + "callFrame": { + "functionName": "q", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9835 + }, + "hitCount": 0, + "children": [ + 70 + ] + }, + { + "id": 70, + "callFrame": { + "functionName": "r", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9943 + }, + "hitCount": 0, + "children": [ + 71 + ] + }, + { + "id": 71, + "callFrame": { + "functionName": "h", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 7884 + }, + "hitCount": 100, + "positionTicks": [ + { + "line": 8, + "ticks": 100 + } + ] + }, + { + "id": 64, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9736 + }, + "hitCount": 0, + "children": [ + 65 + ] + }, + { + "id": 65, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 6233 + }, + "hitCount": 65, + "positionTicks": [ + { + "line": 8, + "ticks": 65 + } + ] + }, + { + "id": 30, + "callFrame": { + "functionName": "J", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 2880 + }, + "hitCount": 1, + "children": [ + 31, + 62 + ], + "positionTicks": [ + { + "line": 136, + "ticks": 1 + } + ] + }, + { + "id": 31, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 8601 + }, + "hitCount": 41, + "children": [ + 32 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 41 + } + ] + }, + { + "id": 32, + "callFrame": { + "functionName": "c", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5822 + }, + "hitCount": 0, + "children": [ + 33, + 35 + ] + }, + { + "id": 33, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5864 + }, + "hitCount": 862, + "children": [ + 34 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 862 + } + ] + }, + { + "id": 34, + "callFrame": { + "functionName": "j", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 6345 + }, + "hitCount": 3576, + "children": [ + 63 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 3 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 142, + "ticks": 3 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 142, + "ticks": 2 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 4 + }, + { + "line": 27, + "ticks": 3 + }, + { + "line": 27, + "ticks": 3 + }, + { + "line": 27, + "ticks": 17 + }, + { + "line": 27, + "ticks": 9 + }, + { + "line": 142, + "ticks": 8 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 142, + "ticks": 9 + }, + { + "line": 27, + "ticks": 5 + }, + { + "line": 27, + "ticks": 13 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 19 + }, + { + "line": 27, + "ticks": 4 + }, + { + "line": 27, + "ticks": 448 + }, + { + "line": 27, + "ticks": 4 + }, + { + "line": 27, + "ticks": 27 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 26 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 7 + }, + { + "line": 27, + "ticks": 3 + }, + { + "line": 27, + "ticks": 369 + }, + { + "line": 27, + "ticks": 387 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 26 + }, + { + "line": 27, + "ticks": 109 + }, + { + "line": 27, + "ticks": 362 + }, + { + "line": 27, + "ticks": 463 + }, + { + "line": 27, + "ticks": 107 + }, + { + "line": 27, + "ticks": 235 + }, + { + "line": 27, + "ticks": 447 + }, + { + "line": 142, + "ticks": 7 + }, + { + "line": 27, + "ticks": 430 + } + ] + }, + { + "id": 63, + "callFrame": { + "functionName": "join", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 18363 + }, + "hitCount": 354, + "children": [ + 368 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 9 + }, + { + "line": 27, + "ticks": 345 + } + ] + }, + { + "id": 368, + "callFrame": { + "functionName": "normalize", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 18105 + }, + "hitCount": 0, + "children": [ + 369 + ] + }, + { + "id": 369, + "callFrame": { + "functionName": "pd", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 10423 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 35, + "callFrame": { + "functionName": "s", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12027 + }, + "hitCount": 0, + "children": [ + 36, + 38 + ] + }, + { + "id": 36, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12075 + }, + "hitCount": 40, + "children": [ + 37 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 40 + } + ] + }, + { + "id": 37, + "callFrame": { + "functionName": "file", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 57791 + }, + "hitCount": 643, + "children": [ + 66 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 19 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 9 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 8 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 4 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 28, + "ticks": 532 + } + ] + }, + { + "id": 66, + "callFrame": { + "functionName": "Pa", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 58904 + }, + "hitCount": 0, + "children": [ + 67 + ] + }, + { + "id": 67, + "callFrame": { + "functionName": "Jm", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56907 + }, + "hitCount": 0, + "children": [ + 68, + 390 + ] + }, + { + "id": 68, + "callFrame": { + "functionName": "WM", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 55722 + }, + "hitCount": 132, + "positionTicks": [ + { + "line": 28, + "ticks": 78 + }, + { + "line": 28, + "ticks": 54 + } + ] + }, + { + "id": 390, + "callFrame": { + "functionName": "VM", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56421 + }, + "hitCount": 7, + "positionTicks": [ + { + "line": 28, + "ticks": 7 + } + ] + }, + { + "id": 38, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12365 + }, + "hitCount": 4, + "children": [ + 39, + 502 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 4 + } + ] + }, + { + "id": 39, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 1, + "children": [ + 40 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 40, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 16, + "children": [ + 41, + 43, + 53, + 577, + 743 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 2, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 12 + } + ] + }, + { + "id": 41, + "callFrame": { + "functionName": "serializeRequestArguments", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124548 + }, + "hitCount": 0, + "children": [ + 42 + ] + }, + { + "id": 42, + "callFrame": { + "functionName": "oE", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116912 + }, + "hitCount": 1474, + "children": [ + 333 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1474 + } + ] + }, + { + "id": 333, + "callFrame": { + "functionName": "toJSON", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 59147 + }, + "hitCount": 42, + "positionTicks": [ + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 9 + } + ] + }, + { + "id": 43, + "callFrame": { + "functionName": "serializeRequest", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124944 + }, + "hitCount": 2, + "children": [ + 44, + 310 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 44, + "callFrame": { + "functionName": "b", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 125054 + }, + "hitCount": 5, + "children": [ + 45, + 244, + 358, + 526, + 559, + 776 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 5 + } + ] + }, + { + "id": 45, + "callFrame": { + "functionName": "fromString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86344 + }, + "hitCount": 6, + "children": [ + 46 + ], + "positionTicks": [ + { + "line": 464, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 461, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 490, + "ticks": 1 + }, + { + "line": 463, + "ticks": 1 + } + ] + }, + { + "id": 46, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 47 + ] + }, + { + "id": 47, + "callFrame": { + "functionName": "fromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 479, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 48 + ] + }, + { + "id": 48, + "callFrame": { + "functionName": "fromStringFast", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 446, + "columnNumber": 23 + }, + "hitCount": 1, + "children": [ + 49, + 241, + 525 + ], + "positionTicks": [ + { + "line": 453, + "ticks": 1 + } + ] + }, + { + "id": 49, + "callFrame": { + "functionName": "createFromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 473, + "columnNumber": 25 + }, + "hitCount": 2, + "children": [ + 50, + 56, + 58 + ], + "positionTicks": [ + { + "line": 1099, + "ticks": 1 + }, + { + "line": 1095, + "ticks": 1 + } + ] + }, + { + "id": 50, + "callFrame": { + "functionName": "allocUnsafeSlow", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 416, + "columnNumber": 49 + }, + "hitCount": 0, + "children": [ + 51 + ] + }, + { + "id": 51, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 52 + ] + }, + { + "id": 52, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 148, + "positionTicks": [ + { + "line": 961, + "ticks": 148 + } + ] + }, + { + "id": 56, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1064, + "positionTicks": [ + { + "line": 474, + "ticks": 1064 + } + ] + }, + { + "id": 58, + "callFrame": { + "functionName": "write", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 634, + "columnNumber": 11 + }, + "hitCount": 2, + "children": [ + 59 + ], + "positionTicks": [ + { + "line": 635, + "ticks": 2 + } + ] + }, + { + "id": 59, + "callFrame": { + "functionName": "utf8Write", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1060, + "columnNumber": 38 + }, + "hitCount": 0, + "children": [ + 60 + ] + }, + { + "id": 60, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 75, + "positionTicks": [ + { + "line": 1068, + "ticks": 75 + } + ] + }, + { + "id": 241, + "callFrame": { + "functionName": "write", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 634, + "columnNumber": 11 + }, + "hitCount": 1, + "children": [ + 242 + ], + "positionTicks": [ + { + "line": 635, + "ticks": 1 + } + ] + }, + { + "id": 242, + "callFrame": { + "functionName": "utf8Write", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1060, + "columnNumber": 38 + }, + "hitCount": 0, + "children": [ + 243 + ] + }, + { + "id": 243, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 1068, + "ticks": 3 + } + ] + }, + { + "id": 525, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 961, + "ticks": 3 + } + ] + }, + { + "id": 244, + "callFrame": { + "functionName": "writeLongString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 122525 + }, + "hitCount": 0, + "children": [ + 245 + ] + }, + { + "id": 245, + "callFrame": { + "functionName": "set", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 87101 + }, + "hitCount": 36, + "positionTicks": [ + { + "line": 28, + "ticks": 36 + } + ] + }, + { + "id": 358, + "callFrame": { + "functionName": "alloc", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 121701 + }, + "hitCount": 2, + "children": [ + 359 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 359, + "callFrame": { + "functionName": "alloc", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86148 + }, + "hitCount": 0, + "children": [ + 360 + ] + }, + { + "id": 360, + "callFrame": { + "functionName": "allocUnsafe", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 406, + "columnNumber": 41 + }, + "hitCount": 0, + "children": [ + 361 + ] + }, + { + "id": 361, + "callFrame": { + "functionName": "allocate", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 431, + "columnNumber": 17 + }, + "hitCount": 1, + "children": [ + 362 + ], + "positionTicks": [ + { + "line": 444, + "ticks": 1 + } + ] + }, + { + "id": 362, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 363 + ] + }, + { + "id": 363, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 117, + "positionTicks": [ + { + "line": 961, + "ticks": 117 + } + ] + }, + { + "id": 526, + "callFrame": { + "functionName": "writeShortString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 122239 + }, + "hitCount": 0, + "children": [ + 527 + ] + }, + { + "id": 527, + "callFrame": { + "functionName": "set", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 87101 + }, + "hitCount": 4, + "positionTicks": [ + { + "line": 28, + "ticks": 4 + } + ] + }, + { + "id": 559, + "callFrame": { + "functionName": "write", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 634, + "columnNumber": 11 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 1061, + "ticks": 2 + } + ] + }, + { + "id": 776, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1094, + "ticks": 1 + } + ] + }, + { + "id": 310, + "callFrame": { + "functionName": "fromString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86344 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 28, + "ticks": 2 + } + ] + }, + { + "id": 53, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 54 + ] + }, + { + "id": 54, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 55 + ] + }, + { + "id": 55, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 615, + "children": [ + 57 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 615 + } + ] + }, + { + "id": 57, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 492, + "positionTicks": [ + { + "line": 2, + "ticks": 492 + } + ] + }, + { + "id": 577, + "callFrame": { + "functionName": "F", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 117946 + }, + "hitCount": 0, + "children": [ + 578 + ] + }, + { + "id": 578, + "callFrame": { + "functionName": "schedule", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 75636 + }, + "hitCount": 1, + "children": [ + 774 + ], + "positionTicks": [ + { + "line": 139, + "ticks": 1 + } + ] + }, + { + "id": 774, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 775 + ] + }, + { + "id": 775, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 743, + "callFrame": { + "functionName": "s3", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 24, + "columnNumber": 1332 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 25, + "ticks": 2 + } + ] + }, + { + "id": 502, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118418 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 62, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10259 + }, + "hitCount": 995, + "positionTicks": [ + { + "line": 107, + "ticks": 2 + }, + { + "line": 107, + "ticks": 4 + }, + { + "line": 107, + "ticks": 4 + }, + { + "line": 107, + "ticks": 4 + }, + { + "line": 107, + "ticks": 981 + } + ] + }, + { + "id": 551, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10259 + }, + "hitCount": 5, + "positionTicks": [ + { + "line": 107, + "ticks": 1 + }, + { + "line": 107, + "ticks": 4 + } + ] + }, + { + "id": 584, + "callFrame": { + "functionName": "file", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 57791 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 28, + "ticks": 2 + } + ] + }, + { + "id": 377, + "callFrame": { + "functionName": "decode", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 8, + "positionTicks": [ + { + "line": 136, + "ticks": 8 + } + ] + }, + { + "id": 391, + "callFrame": { + "functionName": "c", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 57887 + }, + "hitCount": 0, + "children": [ + 392 + ] + }, + { + "id": 392, + "callFrame": { + "functionName": "update", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 36579 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 2, + "ticks": 2 + } + ] + }, + { + "id": 731, + "callFrame": { + "functionName": "Ze", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 46226 + }, + "hitCount": 0, + "children": [ + 732 + ] + }, + { + "id": 732, + "callFrame": { + "functionName": "Writable.write", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 503, + "columnNumber": 35 + }, + "hitCount": 0, + "children": [ + 733 + ] + }, + { + "id": 733, + "callFrame": { + "functionName": "_write", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 452, + "columnNumber": 15 + }, + "hitCount": 0, + "children": [ + 734 + ] + }, + { + "id": 734, + "callFrame": { + "functionName": "writeOrBuffer", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 547, + "columnNumber": 22 + }, + "hitCount": 0, + "children": [ + 735 + ] + }, + { + "id": 735, + "callFrame": { + "functionName": "_write", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 17425 + }, + "hitCount": 0, + "children": [ + 736 + ] + }, + { + "id": 736, + "callFrame": { + "functionName": "startLoop", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 18058 + }, + "hitCount": 0, + "children": [ + 737 + ] + }, + { + "id": 737, + "callFrame": { + "functionName": "getData", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 21249 + }, + "hitCount": 0, + "children": [ + 738 + ] + }, + { + "id": 738, + "callFrame": { + "functionName": "dataMessage", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 22111 + }, + "hitCount": 0, + "children": [ + 739 + ] + }, + { + "id": 739, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 0, + "children": [ + 740 + ] + }, + { + "id": 740, + "callFrame": { + "functionName": "Bo", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 45256 + }, + "hitCount": 0, + "children": [ + 741 + ] + }, + { + "id": 741, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 0, + "children": [ + 742 + ] + }, + { + "id": 742, + "callFrame": { + "functionName": "s", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 30368 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3, + "ticks": 1 + } + ] + }, + { + "id": 311, + "callFrame": { + "functionName": "maybeReadMore", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 856, + "columnNumber": 22 + }, + "hitCount": 1, + "children": [ + 312 + ], + "positionTicks": [ + { + "line": 860, + "ticks": 1 + } + ] + }, + { + "id": 312, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 313, + 357 + ] + }, + { + "id": 313, + "callFrame": { + "functionName": "nextTick", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 112, + "columnNumber": 17 + }, + "hitCount": 14, + "positionTicks": [ + { + "line": 139, + "ticks": 1 + }, + { + "line": 137, + "ticks": 8 + }, + { + "line": 140, + "ticks": 1 + }, + { + "line": 138, + "ticks": 3 + }, + { + "line": 113, + "ticks": 1 + } + ] + }, + { + "id": 357, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 20, + "positionTicks": [ + { + "line": 2, + "ticks": 20 + } + ] + }, + { + "id": 645, + "callFrame": { + "functionName": "write", + "scriptId": "86", + "url": "node:string_decoder", + "lineNumber": 93, + "columnNumber": 46 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 104, + "ticks": 1 + } + ] + }, + { + "id": 500, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 1152 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 136, + "ticks": 2 + } + ] + }, + { + "id": 544, + "callFrame": { + "functionName": "_unrefTimer", + "scriptId": "94", + "url": "node:net", + "lineNumber": 519, + "columnNumber": 51 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 520, + "ticks": 1 + } + ] + }, + { + "id": 547, + "callFrame": { + "functionName": "Socket.read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 779, + "columnNumber": 32 + }, + "hitCount": 0, + "children": [ + 548 + ] + }, + { + "id": 548, + "callFrame": { + "functionName": "Readable.read", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 646, + "columnNumber": 34 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 674, + "ticks": 1 + } + ] + }, + { + "id": 549, + "callFrame": { + "functionName": "nextTick", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 112, + "columnNumber": 17 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 113, + "ticks": 1 + } + ] + }, + { + "id": 558, + "callFrame": { + "functionName": "get", + "scriptId": "102", + "url": "node:internal/streams/duplex", + "lineNumber": 160, + "columnNumber": 7 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 161, + "ticks": 1 + } + ] + }, + { + "id": 580, + "callFrame": { + "functionName": "get", + "scriptId": "94", + "url": "node:net", + "lineNumber": 703, + "columnNumber": 15 + }, + "hitCount": 4, + "positionTicks": [ + { + "line": 704, + "ticks": 4 + } + ] + }, + { + "id": 644, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 961, + "ticks": 2 + } + ] + }, + { + "id": 61, + "callFrame": { + "functionName": "(garbage collector)", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 5260 + }, + { + "id": 72, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 84228 + }, + "hitCount": 0, + "children": [ + 73, + 82 + ] + }, + { + "id": 73, + "callFrame": { + "functionName": "emit", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 64498 + }, + "hitCount": 0, + "children": [ + 74, + 77 + ] + }, + { + "id": 74, + "callFrame": { + "functionName": "Tn", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 64123 + }, + "hitCount": 0, + "children": [ + 75 + ] + }, + { + "id": 75, + "callFrame": { + "functionName": "Event", + "scriptId": "60", + "url": "node:internal/event_target", + "lineNumber": 113, + "columnNumber": 13 + }, + "hitCount": 0, + "children": [ + 76 + ] + }, + { + "id": 76, + "callFrame": { + "functionName": "now", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 77, + "callFrame": { + "functionName": "dispatchEvent", + "scriptId": "60", + "url": "node:internal/event_target", + "lineNumber": 749, + "columnNumber": 15 + }, + "hitCount": 0, + "children": [ + 78 + ] + }, + { + "id": 78, + "callFrame": { + "functionName": "", + "scriptId": "60", + "url": "node:internal/event_target", + "lineNumber": 766, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 79 + ] + }, + { + "id": 79, + "callFrame": { + "functionName": "n", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 64293 + }, + "hitCount": 0, + "children": [ + 80 + ] + }, + { + "id": 80, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 2, + "columnNumber": 44716 + }, + "hitCount": 1, + "children": [ + 81, + 534 + ], + "positionTicks": [ + { + "line": 3, + "ticks": 1 + } + ] + }, + { + "id": 81, + "callFrame": { + "functionName": "ri", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77996 + }, + "hitCount": 5, + "children": [ + 370 + ], + "positionTicks": [ + { + "line": 1, + "ticks": 5 + } + ] + }, + { + "id": 370, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 371 + ] + }, + { + "id": 371, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 372 + ] + }, + { + "id": 372, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 373 + ] + }, + { + "id": 373, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 374 + ] + }, + { + "id": 374, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77531 + }, + "hitCount": 0, + "children": [ + 375 + ] + }, + { + "id": 375, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 376 + ] + }, + { + "id": 376, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 1, + "children": [ + 769 + ], + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 769, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77531 + }, + "hitCount": 0, + "children": [ + 770 + ] + }, + { + "id": 770, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 534, + "callFrame": { + "functionName": "updateCommits", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 2, + "columnNumber": 45570 + }, + "hitCount": 0, + "children": [ + 535 + ] + }, + { + "id": 535, + "callFrame": { + "functionName": "t", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 1030 + }, + "hitCount": 0, + "children": [ + 536 + ] + }, + { + "id": 536, + "callFrame": { + "functionName": "t", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 1030 + }, + "hitCount": 0, + "children": [ + 537 + ] + }, + { + "id": 537, + "callFrame": { + "functionName": "t", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 1030 + }, + "hitCount": 1, + "children": [ + 574 + ], + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 574, + "callFrame": { + "functionName": "t", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 1030 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 1, + "ticks": 2 + } + ] + }, + { + "id": 82, + "callFrame": { + "functionName": "ri", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77996 + }, + "hitCount": 2, + "children": [ + 83 + ], + "positionTicks": [ + { + "line": 1, + "ticks": 2 + } + ] + }, + { + "id": 83, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 84 + ] + }, + { + "id": 84, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 85 + ] + }, + { + "id": 85, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 86 + ] + }, + { + "id": 86, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 87 + ] + }, + { + "id": 87, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77531 + }, + "hitCount": 0, + "children": [ + 88 + ] + }, + { + "id": 88, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 1, + "children": [ + 89 + ], + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 89, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 0, + "children": [ + 90 + ] + }, + { + "id": 90, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77531 + }, + "hitCount": 0, + "children": [ + 91 + ] + }, + { + "id": 91, + "callFrame": { + "functionName": "ei", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 77454 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 92, + "callFrame": { + "functionName": "", + "scriptId": "94", + "url": "node:net", + "lineNumber": 343, + "columnNumber": 23 + }, + "hitCount": 1, + "children": [ + 93 + ], + "positionTicks": [ + { + "line": 346, + "ticks": 1 + } + ] + }, + { + "id": 93, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 0, + "children": [ + 94, + 416 + ] + }, + { + "id": 94, + "callFrame": { + "functionName": "", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 454, + "columnNumber": 34 + }, + "hitCount": 0, + "children": [ + 95 + ] + }, + { + "id": 95, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 0, + "children": [ + 96 + ] + }, + { + "id": 96, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 956 + }, + "hitCount": 0, + "children": [ + 97 + ] + }, + { + "id": 97, + "callFrame": { + "functionName": "s", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 703 + }, + "hitCount": 0, + "children": [ + 98 + ] + }, + { + "id": 98, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 133, + "columnNumber": 107 + }, + "hitCount": 1, + "children": [ + 99 + ], + "positionTicks": [ + { + "line": 136, + "ticks": 1 + } + ] + }, + { + "id": 99, + "callFrame": { + "functionName": "c", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 19413 + }, + "hitCount": 0, + "children": [ + 100 + ] + }, + { + "id": 100, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 18906 + }, + "hitCount": 1, + "children": [ + 101 + ], + "positionTicks": [ + { + "line": 132, + "ticks": 1 + } + ] + }, + { + "id": 101, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 19185 + }, + "hitCount": 0, + "children": [ + 102 + ] + }, + { + "id": 102, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 18997 + }, + "hitCount": 0, + "children": [ + 103 + ] + }, + { + "id": 103, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 3483 + }, + "hitCount": 0, + "children": [ + 104, + 114 + ] + }, + { + "id": 104, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 8670 + }, + "hitCount": 0, + "children": [ + 105 + ] + }, + { + "id": 105, + "callFrame": { + "functionName": "c", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5822 + }, + "hitCount": 2, + "children": [ + 106, + 112 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + }, + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 106, + "callFrame": { + "functionName": "s", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12027 + }, + "hitCount": 0, + "children": [ + 107, + 399, + 560 + ] + }, + { + "id": 107, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12365 + }, + "hitCount": 1, + "children": [ + 108 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 108, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 109 + ] + }, + { + "id": 109, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 1, + "children": [ + 110, + 247, + 364 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 110, + "callFrame": { + "functionName": "serializeRequestArguments", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124548 + }, + "hitCount": 0, + "children": [ + 111 + ] + }, + { + "id": 111, + "callFrame": { + "functionName": "oE", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116912 + }, + "hitCount": 8, + "positionTicks": [ + { + "line": 29, + "ticks": 8 + } + ] + }, + { + "id": 247, + "callFrame": { + "functionName": "serializeRequest", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124944 + }, + "hitCount": 0, + "children": [ + 248 + ] + }, + { + "id": 248, + "callFrame": { + "functionName": "b", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 125054 + }, + "hitCount": 0, + "children": [ + 249, + 538 + ] + }, + { + "id": 249, + "callFrame": { + "functionName": "fromString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86344 + }, + "hitCount": 0, + "children": [ + 250 + ] + }, + { + "id": 250, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 251 + ] + }, + { + "id": 251, + "callFrame": { + "functionName": "fromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 479, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 252 + ] + }, + { + "id": 252, + "callFrame": { + "functionName": "fromStringFast", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 446, + "columnNumber": 23 + }, + "hitCount": 0, + "children": [ + 253 + ] + }, + { + "id": 253, + "callFrame": { + "functionName": "createFromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 473, + "columnNumber": 25 + }, + "hitCount": 0, + "children": [ + 254, + 709 + ] + }, + { + "id": 254, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 474, + "ticks": 2 + } + ] + }, + { + "id": 709, + "callFrame": { + "functionName": "allocUnsafeSlow", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 416, + "columnNumber": 49 + }, + "hitCount": 0, + "children": [ + 710 + ] + }, + { + "id": 710, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 711 + ] + }, + { + "id": 711, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 961, + "ticks": 1 + } + ] + }, + { + "id": 538, + "callFrame": { + "functionName": "alloc", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 121701 + }, + "hitCount": 0, + "children": [ + 539 + ] + }, + { + "id": 539, + "callFrame": { + "functionName": "alloc", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86148 + }, + "hitCount": 0, + "children": [ + 540 + ] + }, + { + "id": 540, + "callFrame": { + "functionName": "allocUnsafe", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 406, + "columnNumber": 41 + }, + "hitCount": 0, + "children": [ + 541 + ] + }, + { + "id": 541, + "callFrame": { + "functionName": "allocate", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 431, + "columnNumber": 17 + }, + "hitCount": 0, + "children": [ + 542 + ] + }, + { + "id": 542, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 543 + ] + }, + { + "id": 543, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 961, + "ticks": 1 + } + ] + }, + { + "id": 364, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 365 + ] + }, + { + "id": 365, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 366 + ] + }, + { + "id": 366, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 3, + "children": [ + 367 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 3 + } + ] + }, + { + "id": 367, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 4, + "positionTicks": [ + { + "line": 2, + "ticks": 4 + } + ] + }, + { + "id": 399, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12075 + }, + "hitCount": 0, + "children": [ + 400 + ] + }, + { + "id": 400, + "callFrame": { + "functionName": "file", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 57791 + }, + "hitCount": 2, + "children": [ + 401 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 401, + "callFrame": { + "functionName": "Pa", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 58904 + }, + "hitCount": 0, + "children": [ + 402 + ] + }, + { + "id": 402, + "callFrame": { + "functionName": "Jm", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56907 + }, + "hitCount": 0, + "children": [ + 403 + ] + }, + { + "id": 403, + "callFrame": { + "functionName": "VM", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56421 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 560, + "callFrame": { + "functionName": "debug", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 15868 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 32, + "ticks": 1 + } + ] + }, + { + "id": 112, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5864 + }, + "hitCount": 2, + "children": [ + 113 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 2 + } + ] + }, + { + "id": 113, + "callFrame": { + "functionName": "j", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 6345 + }, + "hitCount": 13, + "children": [ + 351 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 4 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 2 + }, + { + "line": 27, + "ticks": 1 + }, + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 351, + "callFrame": { + "functionName": "join", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 18363 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 114, + "callFrame": { + "functionName": "c", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5822 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 416, + "callFrame": { + "functionName": "onceWrapper", + "scriptId": "22", + "url": "node:events", + "lineNumber": 627, + "columnNumber": 20 + }, + "hitCount": 0, + "children": [ + 417 + ] + }, + { + "id": 417, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 28465 + }, + "hitCount": 0, + "children": [ + 418 + ] + }, + { + "id": 418, + "callFrame": { + "functionName": "concat", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 577, + "columnNumber": 31 + }, + "hitCount": 0, + "children": [ + 419 + ] + }, + { + "id": 419, + "callFrame": { + "functionName": "allocUnsafe", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 406, + "columnNumber": 41 + }, + "hitCount": 0, + "children": [ + 420 + ] + }, + { + "id": 420, + "callFrame": { + "functionName": "allocate", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 431, + "columnNumber": 17 + }, + "hitCount": 0, + "children": [ + 421 + ] + }, + { + "id": 421, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 422 + ] + }, + { + "id": 422, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 961, + "ticks": 1 + } + ] + }, + { + "id": 115, + "callFrame": { + "functionName": "processTimers", + "scriptId": "10", + "url": "node:internal/timers", + "lineNumber": 507, + "columnNumber": 24 + }, + "hitCount": 0, + "children": [ + 116 + ] + }, + { + "id": 116, + "callFrame": { + "functionName": "listOnTimeout", + "scriptId": "10", + "url": "node:internal/timers", + "lineNumber": 527, + "columnNumber": 24 + }, + "hitCount": 0, + "children": [ + 117, + 379, + 456 + ] + }, + { + "id": 117, + "callFrame": { + "functionName": "", + "scriptId": "577", + "url": "piiRemoved/bufferedQueue.js", + "lineNumber": 39, + "columnNumber": 38 + }, + "hitCount": 0, + "children": [ + 118 + ] + }, + { + "id": 118, + "callFrame": { + "functionName": "run", + "scriptId": "577", + "url": "piiRemoved/bufferedQueue.js", + "lineNumber": 45, + "columnNumber": 7 + }, + "hitCount": 0, + "children": [ + 119 + ] + }, + { + "id": 119, + "callFrame": { + "functionName": "", + "scriptId": "577", + "url": "piiRemoved/bufferedQueue.js", + "lineNumber": 3, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 120 + ] + }, + { + "id": 120, + "callFrame": { + "functionName": "", + "scriptId": "577", + "url": "piiRemoved/bufferedQueue.js", + "lineNumber": 46, + "columnNumber": 57 + }, + "hitCount": 0, + "children": [ + 121 + ] + }, + { + "id": 121, + "callFrame": { + "functionName": "processOnWatcherCreateEvent", + "scriptId": "576", + "url": "piiRemoved/repoManager.js", + "lineNumber": 399, + "columnNumber": 31 + }, + "hitCount": 0, + "children": [ + 122 + ] + }, + { + "id": 122, + "callFrame": { + "functionName": "", + "scriptId": "576", + "url": "piiRemoved/repoManager.js", + "lineNumber": 4, + "columnNumber": 45 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 9, + "ticks": 1 + } + ] + }, + { + "id": 379, + "callFrame": { + "functionName": "", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 169, + "columnNumber": 798 + }, + "hitCount": 0, + "children": [ + 380 + ] + }, + { + "id": 380, + "callFrame": { + "functionName": "_poll", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 169, + "columnNumber": 534 + }, + "hitCount": 0, + "children": [ + 381, + 744 + ] + }, + { + "id": 381, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 105051 + }, + "hitCount": 0, + "children": [ + 382 + ] + }, + { + "id": 382, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 1, + "children": [ + 383 + ], + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 383, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 0, + "children": [ + 384, + 505, + 515 + ] + }, + { + "id": 384, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 385 + ] + }, + { + "id": 385, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 386, + 779 + ] + }, + { + "id": 386, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 387 + ] + }, + { + "id": 387, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 388 + ] + }, + { + "id": 388, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 1, + "children": [ + 389 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 389, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 2, + "ticks": 3 + } + ] + }, + { + "id": 779, + "callFrame": { + "functionName": "serializeRequest", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124944 + }, + "hitCount": 0, + "children": [ + 780 + ] + }, + { + "id": 780, + "callFrame": { + "functionName": "b", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 125054 + }, + "hitCount": 0, + "children": [ + 781 + ] + }, + { + "id": 781, + "callFrame": { + "functionName": "fromString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86344 + }, + "hitCount": 0, + "children": [ + 782 + ] + }, + { + "id": 782, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 783 + ] + }, + { + "id": 783, + "callFrame": { + "functionName": "fromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 479, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 784 + ] + }, + { + "id": 784, + "callFrame": { + "functionName": "fromStringFast", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 446, + "columnNumber": 23 + }, + "hitCount": 0, + "children": [ + 785 + ] + }, + { + "id": 785, + "callFrame": { + "functionName": "write", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 634, + "columnNumber": 11 + }, + "hitCount": 0, + "children": [ + 786 + ] + }, + { + "id": 786, + "callFrame": { + "functionName": "utf8Write", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1060, + "columnNumber": 38 + }, + "hitCount": 0, + "children": [ + 787 + ] + }, + { + "id": 787, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1068, + "ticks": 1 + } + ] + }, + { + "id": 505, + "callFrame": { + "functionName": "now", + "scriptId": "134", + "url": "node:internal/perf/performance", + "lineNumber": 136, + "columnNumber": 5 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 537, + "ticks": 1 + } + ] + }, + { + "id": 515, + "callFrame": { + "functionName": "h", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 41255 + }, + "hitCount": 1, + "children": [ + 516 + ], + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 516, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 122, + "columnNumber": 26504 + }, + "hitCount": 1, + "children": [ + 517 + ], + "positionTicks": [ + { + "line": 123, + "ticks": 1 + } + ] + }, + { + "id": 517, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 0, + "children": [ + 518 + ] + }, + { + "id": 518, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 1, + "children": [ + 519, + 655 + ], + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 519, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 520 + ] + }, + { + "id": 520, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 521 + ] + }, + { + "id": 521, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 522 + ] + }, + { + "id": 522, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 523 + ] + }, + { + "id": 523, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 524 + ] + }, + { + "id": 524, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 2, + "ticks": 2 + } + ] + }, + { + "id": 655, + "callFrame": { + "functionName": "Na", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24549 + }, + "hitCount": 0, + "children": [ + 656 + ] + }, + { + "id": 656, + "callFrame": { + "functionName": "cv", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24589 + }, + "hitCount": 0, + "children": [ + 657 + ] + }, + { + "id": 657, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40738 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 744, + "callFrame": { + "functionName": "clearTimeout", + "scriptId": "34", + "url": "node:timers", + "lineNumber": 156, + "columnNumber": 21 + }, + "hitCount": 0, + "children": [ + 745 + ] + }, + { + "id": 745, + "callFrame": { + "functionName": "unenroll", + "scriptId": "34", + "url": "node:timers", + "lineNumber": 75, + "columnNumber": 17 + }, + "hitCount": 0, + "children": [ + 746 + ] + }, + { + "id": 746, + "callFrame": { + "functionName": "removeAt", + "scriptId": "18", + "url": "node:internal/priority_queue", + "lineNumber": 98, + "columnNumber": 10 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 68, + "ticks": 1 + } + ] + }, + { + "id": 456, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 99055 + }, + "hitCount": 0, + "children": [ + 457 + ] + }, + { + "id": 457, + "callFrame": { + "functionName": "eventuallyUpdateResourceStates", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 51996 + }, + "hitCount": 0, + "children": [ + 458, + 700 + ] + }, + { + "id": 458, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 52025 + }, + "hitCount": 0, + "children": [ + 459 + ] + }, + { + "id": 459, + "callFrame": { + "functionName": "_takeResourceStateSnapshot", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 46305 + }, + "hitCount": 0, + "children": [ + 460, + 675, + 696 + ] + }, + { + "id": 460, + "callFrame": { + "functionName": "y5", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 1618 + }, + "hitCount": 0, + "children": [ + 461 + ] + }, + { + "id": 461, + "callFrame": { + "functionName": "KD", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 42886 + }, + "hitCount": 0, + "children": [ + 462, + 681 + ] + }, + { + "id": 462, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 231150 + }, + "hitCount": 0, + "children": [ + 463 + ] + }, + { + "id": 463, + "callFrame": { + "functionName": "get command", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 550679 + }, + "hitCount": 0, + "children": [ + 464, + 677 + ] + }, + { + "id": 464, + "callFrame": { + "functionName": "resolveChangeCommand", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 557445 + }, + "hitCount": 0, + "children": [ + 465, + 682, + 694 + ] + }, + { + "id": 465, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 122133 + }, + "hitCount": 0, + "children": [ + 466 + ] + }, + { + "id": 466, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 1, + "children": [ + 467 + ], + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 467, + "callFrame": { + "functionName": "Rs", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24920 + }, + "hitCount": 2, + "children": [ + 680 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 680, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24975 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 682, + "callFrame": { + "functionName": "get leftUri", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 550463 + }, + "hitCount": 0, + "children": [ + 683 + ] + }, + { + "id": 683, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 231150 + }, + "hitCount": 0, + "children": [ + 684 + ] + }, + { + "id": 684, + "callFrame": { + "functionName": "get resources", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 550752 + }, + "hitCount": 0, + "children": [ + 685 + ] + }, + { + "id": 685, + "callFrame": { + "functionName": "getResources", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 558268 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 694, + "callFrame": { + "functionName": "getTitle", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 559594 + }, + "hitCount": 0, + "children": [ + 695 + ] + }, + { + "id": 695, + "callFrame": { + "functionName": "t", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 128230 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 201, + "ticks": 1 + } + ] + }, + { + "id": 677, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 0, + "children": [ + 678, + 686 + ] + }, + { + "id": 678, + "callFrame": { + "functionName": "Rs", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24920 + }, + "hitCount": 3, + "children": [ + 679 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 3 + } + ] + }, + { + "id": 679, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24975 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 686, + "callFrame": { + "functionName": "getValue", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 112, + "columnNumber": 14119 + }, + "hitCount": 0, + "children": [ + 687 + ] + }, + { + "id": 687, + "callFrame": { + "functionName": "w", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 112, + "columnNumber": 18031 + }, + "hitCount": 0, + "children": [ + 688 + ] + }, + { + "id": 688, + "callFrame": { + "functionName": "x", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 112, + "columnNumber": 18249 + }, + "hitCount": 0, + "children": [ + 689 + ] + }, + { + "id": 689, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 4794 + }, + "hitCount": 0, + "children": [ + 690 + ] + }, + { + "id": 690, + "callFrame": { + "functionName": "Jt.c", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 4513 + }, + "hitCount": 0, + "children": [ + 691 + ] + }, + { + "id": 691, + "callFrame": { + "functionName": "toString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 59048 + }, + "hitCount": 0, + "children": [ + 692 + ] + }, + { + "id": 692, + "callFrame": { + "functionName": "H1", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 60686 + }, + "hitCount": 0, + "children": [ + 693 + ] + }, + { + "id": 693, + "callFrame": { + "functionName": "ES", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 59645 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 681, + "callFrame": { + "functionName": "am", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 9232 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 132, + "ticks": 1 + } + ] + }, + { + "id": 675, + "callFrame": { + "functionName": "KD", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 42886 + }, + "hitCount": 0, + "children": [ + 676 + ] + }, + { + "id": 676, + "callFrame": { + "functionName": "am", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 9232 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 132, + "ticks": 1 + } + ] + }, + { + "id": 696, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 46359 + }, + "hitCount": 0, + "children": [ + 697 + ] + }, + { + "id": 697, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 46386 + }, + "hitCount": 0, + "children": [ + 698 + ] + }, + { + "id": 698, + "callFrame": { + "functionName": "s4", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 41080 + }, + "hitCount": 0, + "children": [ + 699 + ] + }, + { + "id": 699, + "callFrame": { + "functionName": "n", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 42, + "columnNumber": 28715 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 43, + "ticks": 1 + } + ] + }, + { + "id": 700, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 701 + ] + }, + { + "id": 701, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 702, + 704 + ] + }, + { + "id": 702, + "callFrame": { + "functionName": "serializeRequestArguments", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124548 + }, + "hitCount": 0, + "children": [ + 703 + ] + }, + { + "id": 703, + "callFrame": { + "functionName": "oE", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116912 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 704, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 705 + ] + }, + { + "id": 705, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 706 + ] + }, + { + "id": 706, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 707 + ] + }, + { + "id": 707, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 123, + "callFrame": { + "functionName": "MessagePortMain._internalPort.emit", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 2862 + }, + "hitCount": 1, + "children": [ + 124 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 124, + "callFrame": { + "functionName": "emit", + "scriptId": "22", + "url": "node:events", + "lineNumber": 465, + "columnNumber": 43 + }, + "hitCount": 4, + "children": [ + 125, + 759 + ], + "positionTicks": [ + { + "line": 513, + "ticks": 3 + }, + { + "line": 519, + "ticks": 1 + } + ] + }, + { + "id": 125, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 6902 + }, + "hitCount": 3, + "children": [ + 126, + 754 + ], + "positionTicks": [ + { + "line": 553, + "ticks": 2 + }, + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 126, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 9408 + }, + "hitCount": 0, + "children": [ + 127 + ] + }, + { + "id": 127, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 128 + ] + }, + { + "id": 128, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 129 + ] + }, + { + "id": 129, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8520 + }, + "hitCount": 0, + "children": [ + 130 + ] + }, + { + "id": 130, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 9408 + }, + "hitCount": 0, + "children": [ + 131 + ] + }, + { + "id": 131, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 132 + ] + }, + { + "id": 132, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 133, + 503 + ] + }, + { + "id": 133, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 117726 + }, + "hitCount": 0, + "children": [ + 134 + ] + }, + { + "id": 134, + "callFrame": { + "functionName": "L", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118730 + }, + "hitCount": 1, + "children": [ + 135, + 143, + 167, + 471, + 594 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 135, + "callFrame": { + "functionName": "deserializeReplyOKJSON", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 126862 + }, + "hitCount": 3898, + "children": [ + 136 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 3898 + } + ] + }, + { + "id": 136, + "callFrame": { + "functionName": "readLongString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 122637 + }, + "hitCount": 0, + "children": [ + 137 + ] + }, + { + "id": 137, + "callFrame": { + "functionName": "toString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86960 + }, + "hitCount": 0, + "children": [ + 138 + ] + }, + { + "id": 138, + "callFrame": { + "functionName": "toString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 834, + "columnNumber": 45 + }, + "hitCount": 936, + "positionTicks": [ + { + "line": 837, + "ticks": 936 + } + ] + }, + { + "id": 143, + "callFrame": { + "functionName": "M", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 119649 + }, + "hitCount": 1, + "children": [ + 144, + 176 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 144, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 145 + ] + }, + { + "id": 145, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 146 + ] + }, + { + "id": 146, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 147 + ] + }, + { + "id": 147, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 10, + "positionTicks": [ + { + "line": 2, + "ticks": 10 + } + ] + }, + { + "id": 176, + "callFrame": { + "functionName": "Q", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120703 + }, + "hitCount": 0, + "children": [ + 177 + ] + }, + { + "id": 177, + "callFrame": { + "functionName": "S", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120789 + }, + "hitCount": 0, + "children": [ + 178, + 408, + 468 + ] + }, + { + "id": 178, + "callFrame": { + "functionName": "$onFileEvent", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 123420 + }, + "hitCount": 1, + "children": [ + 179 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 179, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 180, + 528 + ] + }, + { + "id": 180, + "callFrame": { + "functionName": "D", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2397 + }, + "hitCount": 1, + "children": [ + 181 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 181, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 182, + 556 + ] + }, + { + "id": 182, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 121048 + }, + "hitCount": 2, + "children": [ + 183, + 190, + 214, + 234, + 292, + 778 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + }, + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 183, + "callFrame": { + "functionName": "getWorkspaceFolder", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 67918 + }, + "hitCount": 0, + "children": [ + 184 + ] + }, + { + "id": 184, + "callFrame": { + "functionName": "getWorkspaceFolder", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 65835 + }, + "hitCount": 0, + "children": [ + 185 + ] + }, + { + "id": 185, + "callFrame": { + "functionName": "findSubstr", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 40, + "columnNumber": 7104 + }, + "hitCount": 2, + "children": [ + 186 + ], + "positionTicks": [ + { + "line": 41, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 186, + "callFrame": { + "functionName": "reset", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 40, + "columnNumber": 2091 + }, + "hitCount": 0, + "children": [ + 187 + ] + }, + { + "id": 187, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 65315 + }, + "hitCount": 0, + "children": [ + 188 + ] + }, + { + "id": 188, + "callFrame": { + "functionName": "jb", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 64756 + }, + "hitCount": 0, + "children": [ + 189 + ] + }, + { + "id": 189, + "callFrame": { + "functionName": "getCapabilities", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 40, + "columnNumber": 10717 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 41, + "ticks": 1 + } + ] + }, + { + "id": 190, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 191 + ] + }, + { + "id": 191, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 1, + "children": [ + 192, + 198, + 228, + 238, + 296, + 552, + 585, + 760 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 192, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610351 + }, + "hitCount": 0, + "children": [ + 193 + ] + }, + { + "id": 193, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610195 + }, + "hitCount": 0, + "children": [ + 194 + ] + }, + { + "id": 194, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610351 + }, + "hitCount": 0, + "children": [ + 195, + 491 + ] + }, + { + "id": 195, + "callFrame": { + "functionName": "onFileChange", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 602939 + }, + "hitCount": 2, + "children": [ + 196, + 294 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + }, + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 196, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 122133 + }, + "hitCount": 0, + "children": [ + 197 + ] + }, + { + "id": 197, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 4, + "children": [ + 227 + ], + "positionTicks": [ + { + "line": 114, + "ticks": 4 + } + ] + }, + { + "id": 227, + "callFrame": { + "functionName": "Rs", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24920 + }, + "hitCount": 9, + "children": [ + 472 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 7 + } + ] + }, + { + "id": 472, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24975 + }, + "hitCount": 3, + "children": [ + 777 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 3 + } + ] + }, + { + "id": 777, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 5034 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 294, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3501 + }, + "hitCount": 0, + "children": [ + 295 + ] + }, + { + "id": 295, + "callFrame": { + "functionName": "h", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 5536 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 491, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 198, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 304, + "columnNumber": 12062 + }, + "hitCount": 1, + "children": [ + 199 + ], + "positionTicks": [ + { + "line": 222, + "ticks": 1 + } + ] + }, + { + "id": 199, + "callFrame": { + "functionName": "fire", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 1348 + }, + "hitCount": 1, + "children": [ + 200 + ], + "positionTicks": [ + { + "line": 228, + "ticks": 1 + } + ] + }, + { + "id": 200, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8258 + }, + "hitCount": 0, + "children": [ + 201 + ] + }, + { + "id": 201, + "callFrame": { + "functionName": "refresh", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 234, + "columnNumber": 875 + }, + "hitCount": 0, + "children": [ + 202 + ] + }, + { + "id": 202, + "callFrame": { + "functionName": "r", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 239, + "columnNumber": 935 + }, + "hitCount": 0, + "children": [ + 203 + ] + }, + { + "id": 203, + "callFrame": { + "functionName": "findFiles", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 119433 + }, + "hitCount": 0, + "children": [ + 204 + ] + }, + { + "id": 204, + "callFrame": { + "functionName": "findFiles", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 68930 + }, + "hitCount": 0, + "children": [ + 205 + ] + }, + { + "id": 205, + "callFrame": { + "functionName": "z", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 69464 + }, + "hitCount": 1, + "children": [ + 206 + ], + "positionTicks": [ + { + "line": 111, + "ticks": 1 + } + ] + }, + { + "id": 206, + "callFrame": { + "functionName": "A", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70619 + }, + "hitCount": 1, + "children": [ + 207 + ], + "positionTicks": [ + { + "line": 111, + "ticks": 1 + } + ] + }, + { + "id": 207, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70657 + }, + "hitCount": 0, + "children": [ + 208 + ] + }, + { + "id": 208, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 209, + 307 + ] + }, + { + "id": 209, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 210, + 239 + ] + }, + { + "id": 210, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 211 + ] + }, + { + "id": 211, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 212 + ] + }, + { + "id": 212, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 1, + "children": [ + 213 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 213, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 4, + "positionTicks": [ + { + "line": 2, + "ticks": 4 + } + ] + }, + { + "id": 239, + "callFrame": { + "functionName": "serializeRequest", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 124944 + }, + "hitCount": 0, + "children": [ + 240 + ] + }, + { + "id": 240, + "callFrame": { + "functionName": "b", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 125054 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 307, + "callFrame": { + "functionName": "add", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 24, + "columnNumber": 1521 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 25, + "ticks": 1 + } + ] + }, + { + "id": 228, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 304, + "columnNumber": 12116 + }, + "hitCount": 0, + "children": [ + 229, + 561 + ] + }, + { + "id": 229, + "callFrame": { + "functionName": "fire", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 1348 + }, + "hitCount": 9, + "children": [ + 506 + ], + "positionTicks": [ + { + "line": 228, + "ticks": 9 + } + ] + }, + { + "id": 506, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8186 + }, + "hitCount": 0, + "children": [ + 507 + ] + }, + { + "id": 507, + "callFrame": { + "functionName": "fetchAndSet", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 4450 + }, + "hitCount": 0, + "children": [ + 508 + ] + }, + { + "id": 508, + "callFrame": { + "functionName": "fetch", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 4337 + }, + "hitCount": 1, + "children": [ + 509 + ], + "positionTicks": [ + { + "line": 277, + "ticks": 1 + } + ] + }, + { + "id": 509, + "callFrame": { + "functionName": "supports", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 276, + "columnNumber": 11133 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 277, + "ticks": 1 + } + ] + }, + { + "id": 561, + "callFrame": { + "functionName": "re", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8649 + }, + "hitCount": 0, + "children": [ + 562 + ] + }, + { + "id": 562, + "callFrame": { + "functionName": "parse", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 21964 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 222, + "ticks": 1 + } + ] + }, + { + "id": 238, + "callFrame": { + "functionName": "", + "scriptId": "748", + "url": "piiRemoved/extension.js", + "lineNumber": 3001, + "columnNumber": 16211 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3002, + "ticks": 1 + } + ] + }, + { + "id": 296, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 304, + "columnNumber": 12170 + }, + "hitCount": 0, + "children": [ + 297 + ] + }, + { + "id": 297, + "callFrame": { + "functionName": "fire", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 1348 + }, + "hitCount": 1, + "children": [ + 298 + ], + "positionTicks": [ + { + "line": 228, + "ticks": 1 + } + ] + }, + { + "id": 298, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8348 + }, + "hitCount": 0, + "children": [ + 299 + ] + }, + { + "id": 299, + "callFrame": { + "functionName": "delete", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 2397 + }, + "hitCount": 0, + "children": [ + 300 + ] + }, + { + "id": 300, + "callFrame": { + "functionName": "getTrieIdentifier", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 3625 + }, + "hitCount": 0, + "children": [ + 301 + ] + }, + { + "id": 301, + "callFrame": { + "functionName": "yw", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 5328 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 228, + "ticks": 1 + } + ] + }, + { + "id": 552, + "callFrame": { + "functionName": "onWatcherCreate", + "scriptId": "576", + "url": "piiRemoved/repoManager.js", + "lineNumber": 374, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 553 + ] + }, + { + "id": 553, + "callFrame": { + "functionName": "enqueue", + "scriptId": "577", + "url": "piiRemoved/bufferedQueue.js", + "lineNumber": 29, + "columnNumber": 11 + }, + "hitCount": 1, + "children": [ + 763 + ], + "positionTicks": [ + { + "line": 33, + "ticks": 1 + } + ] + }, + { + "id": 763, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 764 + ] + }, + { + "id": 764, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 585, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 13341 + }, + "hitCount": 0, + "children": [ + 586 + ] + }, + { + "id": 586, + "callFrame": { + "functionName": "_triggerOnFileChange", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 14428 + }, + "hitCount": 0, + "children": [ + 587 + ] + }, + { + "id": 587, + "callFrame": { + "functionName": "getIgnoreGlobs", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 13895 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3844, + "ticks": 1 + } + ] + }, + { + "id": 760, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 13448 + }, + "hitCount": 0, + "children": [ + 761 + ] + }, + { + "id": 761, + "callFrame": { + "functionName": "_triggerOnFileChange", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 14428 + }, + "hitCount": 0, + "children": [ + 762 + ] + }, + { + "id": 762, + "callFrame": { + "functionName": "getIgnoreGlobs", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 13895 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3844, + "ticks": 1 + } + ] + }, + { + "id": 214, + "callFrame": { + "functionName": "", + "scriptId": "639", + "url": "piiRemoved/extension.js", + "lineNumber": 0, + "columnNumber": 1282 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1, + "ticks": 1 + } + ] + }, + { + "id": 234, + "callFrame": { + "functionName": "r", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10526 + }, + "hitCount": 0, + "children": [ + 235, + 236 + ] + }, + { + "id": 235, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10259 + }, + "hitCount": 10, + "positionTicks": [ + { + "line": 107, + "ticks": 10 + } + ] + }, + { + "id": 236, + "callFrame": { + "functionName": "i", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 8942 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + }, + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 292, + "callFrame": { + "functionName": "get created", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 122779 + }, + "hitCount": 0, + "children": [ + 293 + ] + }, + { + "id": 293, + "callFrame": { + "functionName": "get value", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 21599 + }, + "hitCount": 2, + "children": [ + 393 + ], + "positionTicks": [ + { + "line": 27, + "ticks": 2 + } + ] + }, + { + "id": 393, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 122908 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 142, + "ticks": 2 + } + ] + }, + { + "id": 778, + "callFrame": { + "functionName": "", + "scriptId": "748", + "url": "piiRemoved/extension.js", + "lineNumber": 3001, + "columnNumber": 16211 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3002, + "ticks": 1 + } + ] + }, + { + "id": 556, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10259 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 107, + "ticks": 1 + } + ] + }, + { + "id": 528, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 121048 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 408, + "callFrame": { + "functionName": "$provideFileSearchResults", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 11747 + }, + "hitCount": 1, + "children": [ + 658 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 658, + "callFrame": { + "functionName": "I", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12300 + }, + "hitCount": 0, + "children": [ + 659 + ] + }, + { + "id": 659, + "callFrame": { + "functionName": "doInternalFileSearchWithCustomCallback", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12011 + }, + "hitCount": 0, + "children": [ + 660 + ] + }, + { + "id": 660, + "callFrame": { + "functionName": "getNumThreadsCached", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 11203 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 468, + "callFrame": { + "functionName": "$provideDecorations", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 4365 + }, + "hitCount": 0, + "children": [ + 469 + ] + }, + { + "id": 469, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 4527 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 121, + "ticks": 1 + } + ] + }, + { + "id": 167, + "callFrame": { + "functionName": "O", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120293 + }, + "hitCount": 12, + "children": [ + 289 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 3 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 1 + }, + { + "line": 29, + "ticks": 3 + }, + { + "line": 29, + "ticks": 3 + } + ] + }, + { + "id": 289, + "callFrame": { + "functionName": "resolveOk", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 121582 + }, + "hitCount": 0, + "children": [ + 290, + 404 + ] + }, + { + "id": 290, + "callFrame": { + "functionName": "resolveOk", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116082 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 404, + "callFrame": { + "functionName": "dispose", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 24, + "columnNumber": 1376 + }, + "hitCount": 0, + "children": [ + 405 + ] + }, + { + "id": 405, + "callFrame": { + "functionName": "clear", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 24, + "columnNumber": 1457 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 25, + "ticks": 2 + } + ] + }, + { + "id": 471, + "callFrame": { + "functionName": "deserializeRequestJSONArgs", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 125319 + }, + "hitCount": 7, + "children": [ + 487 + ], + "positionTicks": [ + { + "line": 29, + "ticks": 7 + } + ] + }, + { + "id": 487, + "callFrame": { + "functionName": "readShortString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 122349 + }, + "hitCount": 0, + "children": [ + 488 + ] + }, + { + "id": 488, + "callFrame": { + "functionName": "slice", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 87051 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 594, + "callFrame": { + "functionName": "G", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118037 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 503, + "callFrame": { + "functionName": "L", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118730 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 754, + "callFrame": { + "functionName": "wrap", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86229 + }, + "hitCount": 0, + "children": [ + 755 + ] + }, + { + "id": 755, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 756 + ] + }, + { + "id": 756, + "callFrame": { + "functionName": "fromArrayBuffer", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 492, + "columnNumber": 24 + }, + "hitCount": 0, + "children": [ + 757 + ] + }, + { + "id": 757, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 961, + "ticks": 1 + } + ] + }, + { + "id": 759, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8520 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 393, + "ticks": 1 + } + ] + }, + { + "id": 139, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70717 + }, + "hitCount": 559, + "children": [ + 140 + ], + "positionTicks": [ + { + "line": 111, + "ticks": 559 + } + ] + }, + { + "id": 140, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70743 + }, + "hitCount": 212, + "children": [ + 141, + 173 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 2 + }, + { + "line": 111, + "ticks": 3 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 11 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 28, + "ticks": 7 + }, + { + "line": 28, + "ticks": 10 + }, + { + "line": 28, + "ticks": 15 + }, + { + "line": 28, + "ticks": 6 + }, + { + "line": 111, + "ticks": 14 + }, + { + "line": 28, + "ticks": 3 + }, + { + "line": 28, + "ticks": 4 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 11 + }, + { + "line": 28, + "ticks": 22 + }, + { + "line": 111, + "ticks": 17 + }, + { + "line": 28, + "ticks": 8 + }, + { + "line": 28, + "ticks": 15 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 12 + }, + { + "line": 28, + "ticks": 15 + } + ] + }, + { + "id": 141, + "callFrame": { + "functionName": "revive", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 58355 + }, + "hitCount": 27, + "children": [ + 168 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 12 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 9 + } + ] + }, + { + "id": 168, + "callFrame": { + "functionName": "Pa", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 58904 + }, + "hitCount": 0, + "children": [ + 169 + ] + }, + { + "id": 169, + "callFrame": { + "functionName": "Jm", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56907 + }, + "hitCount": 116, + "positionTicks": [ + { + "line": 28, + "ticks": 11 + }, + { + "line": 28, + "ticks": 17 + }, + { + "line": 28, + "ticks": 88 + } + ] + }, + { + "id": 173, + "callFrame": { + "functionName": "Pa", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 58904 + }, + "hitCount": 7, + "children": [ + 174 + ], + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 6 + } + ] + }, + { + "id": 174, + "callFrame": { + "functionName": "Jm", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 56907 + }, + "hitCount": 12, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 5 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 2 + }, + { + "line": 28, + "ticks": 1 + }, + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 142, + "callFrame": { + "functionName": "A", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70619 + }, + "hitCount": 115, + "positionTicks": [ + { + "line": 111, + "ticks": 115 + } + ] + }, + { + "id": 148, + "callFrame": { + "functionName": "doInternalFileSearchWithCustomCallback", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 12011 + }, + "hitCount": 0, + "children": [ + 149 + ] + }, + { + "id": 149, + "callFrame": { + "functionName": "doFileSearch", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5703 + }, + "hitCount": 0, + "children": [ + 150 + ] + }, + { + "id": 150, + "callFrame": { + "functionName": "doFileSearchWithEngine", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 5787 + }, + "hitCount": 1, + "children": [ + 151, + 481 + ], + "positionTicks": [ + { + "line": 142, + "ticks": 1 + } + ] + }, + { + "id": 151, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 8532 + }, + "hitCount": 0, + "children": [ + 152, + 489 + ] + }, + { + "id": 152, + "callFrame": { + "functionName": "search", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 3438 + }, + "hitCount": 0, + "children": [ + 153 + ] + }, + { + "id": 153, + "callFrame": { + "functionName": "walk", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 18657 + }, + "hitCount": 0, + "children": [ + 154 + ] + }, + { + "id": 154, + "callFrame": { + "functionName": "w", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 19058 + }, + "hitCount": 0, + "children": [ + 155 + ] + }, + { + "id": 155, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 18871 + }, + "hitCount": 0, + "children": [ + 156 + ] + }, + { + "id": 156, + "callFrame": { + "functionName": "x", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 19282 + }, + "hitCount": 0, + "children": [ + 157 + ] + }, + { + "id": 157, + "callFrame": { + "functionName": "y", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 19338 + }, + "hitCount": 1, + "children": [ + 158, + 771 + ], + "positionTicks": [ + { + "line": 132, + "ticks": 1 + } + ] + }, + { + "id": 158, + "callFrame": { + "functionName": "M_", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 16034 + }, + "hitCount": 0, + "children": [ + 159, + 409 + ] + }, + { + "id": 159, + "callFrame": { + "functionName": "spawn", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 810, + "columnNumber": 14 + }, + "hitCount": 3, + "children": [ + 160, + 161 + ], + "positionTicks": [ + { + "line": 812, + "ticks": 3 + } + ] + }, + { + "id": 160, + "callFrame": { + "functionName": "normalizeSpawnArguments", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 566, + "columnNumber": 32 + }, + "hitCount": 13, + "positionTicks": [ + { + "line": 641, + "ticks": 13 + } + ] + }, + { + "id": 161, + "callFrame": { + "functionName": "spawn", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 353, + "columnNumber": 45 + }, + "hitCount": 3, + "children": [ + 162, + 163, + 309 + ], + "positionTicks": [ + { + "line": 473, + "ticks": 1 + }, + { + "line": 395, + "ticks": 2 + } + ] + }, + { + "id": 162, + "callFrame": { + "functionName": "spawn", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 26, + "positionTicks": [ + { + "line": 395, + "ticks": 26 + } + ] + }, + { + "id": 163, + "callFrame": { + "functionName": "createSocket", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 333, + "columnNumber": 21 + }, + "hitCount": 0, + "children": [ + 164 + ] + }, + { + "id": 164, + "callFrame": { + "functionName": "Socket", + "scriptId": "94", + "url": "node:net", + "lineNumber": 361, + "columnNumber": 15 + }, + "hitCount": 0, + "children": [ + 165 + ] + }, + { + "id": 165, + "callFrame": { + "functionName": "Socket", + "scriptId": "94", + "url": "node:net", + "lineNumber": 361, + "columnNumber": 15 + }, + "hitCount": 2, + "children": [ + 166, + 413, + 490, + 555, + 749 + ], + "positionTicks": [ + { + "line": 408, + "ticks": 1 + }, + { + "line": 417, + "ticks": 1 + } + ] + }, + { + "id": 166, + "callFrame": { + "functionName": "initSocketHandle", + "scriptId": "94", + "url": "node:net", + "lineNumber": 317, + "columnNumber": 25 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 325, + "ticks": 1 + } + ] + }, + { + "id": 413, + "callFrame": { + "functionName": "Readable.on", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1126, + "columnNumber": 32 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1127, + "ticks": 1 + } + ] + }, + { + "id": 490, + "callFrame": { + "functionName": "Stream", + "scriptId": "103", + "url": "node:internal/streams/legacy", + "lineNumber": 10, + "columnNumber": 15 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 11, + "ticks": 1 + } + ] + }, + { + "id": 555, + "callFrame": { + "functionName": "set", + "scriptId": "94", + "url": "node:net", + "lineNumber": 2446, + "columnNumber": 5 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2447, + "ticks": 1 + } + ] + }, + { + "id": 749, + "callFrame": { + "functionName": "Socket.read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 779, + "columnNumber": 32 + }, + "hitCount": 0, + "children": [ + 750 + ] + }, + { + "id": 750, + "callFrame": { + "functionName": "Readable.read", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 646, + "columnNumber": 34 + }, + "hitCount": 0, + "children": [ + 751 + ] + }, + { + "id": 751, + "callFrame": { + "functionName": "Socket._read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 719, + "columnNumber": 33 + }, + "hitCount": 0, + "children": [ + 752 + ] + }, + { + "id": 752, + "callFrame": { + "functionName": "tryReadStart", + "scriptId": "94", + "url": "node:net", + "lineNumber": 709, + "columnNumber": 21 + }, + "hitCount": 0, + "children": [ + 753 + ] + }, + { + "id": 753, + "callFrame": { + "functionName": "readStart", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 714, + "ticks": 1 + } + ] + }, + { + "id": 309, + "callFrame": { + "functionName": "getValidStdio", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 983, + "columnNumber": 22 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 992, + "ticks": 1 + } + ] + }, + { + "id": 409, + "callFrame": { + "functionName": "L_", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 16198 + }, + "hitCount": 2, + "children": [ + 410 + ], + "positionTicks": [ + { + "line": 132, + "ticks": 2 + } + ] + }, + { + "id": 410, + "callFrame": { + "functionName": "JS", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 91989 + }, + "hitCount": 0, + "children": [ + 411 + ] + }, + { + "id": 411, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 9736 + }, + "hitCount": 0, + "children": [ + 412 + ] + }, + { + "id": 412, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 7, + "columnNumber": 6233 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 8, + "ticks": 1 + } + ] + }, + { + "id": 771, + "callFrame": { + "functionName": "z", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 687 + }, + "hitCount": 0, + "children": [ + 772 + ] + }, + { + "id": 772, + "callFrame": { + "functionName": "Readable.on", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1126, + "columnNumber": 32 + }, + "hitCount": 0, + "children": [ + 773 + ] + }, + { + "id": 773, + "callFrame": { + "functionName": "_addListener", + "scriptId": "22", + "url": "node:events", + "lineNumber": 546, + "columnNumber": 21 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 574, + "ticks": 1 + } + ] + }, + { + "id": 489, + "callFrame": { + "functionName": "get onCancellationRequested", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 5207 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 481, + "callFrame": { + "functionName": "U_", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 17858 + }, + "hitCount": 0, + "children": [ + 482 + ] + }, + { + "id": 482, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 131, + "columnNumber": 18294 + }, + "hitCount": 0, + "children": [ + 483 + ] + }, + { + "id": 483, + "callFrame": { + "functionName": "z_", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 3594 + }, + "hitCount": 0, + "children": [ + 484 + ] + }, + { + "id": 484, + "callFrame": { + "functionName": "d", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 3638 + }, + "hitCount": 0, + "children": [ + 485, + 576 + ] + }, + { + "id": 485, + "callFrame": { + "functionName": "Nr", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 106, + "columnNumber": 10419 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 107, + "ticks": 1 + } + ] + }, + { + "id": 576, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 135, + "columnNumber": 3689 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 136, + "ticks": 1 + } + ] + }, + { + "id": 170, + "callFrame": { + "functionName": "Bc", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 221, + "columnNumber": 20641 + }, + "hitCount": 21, + "positionTicks": [ + { + "line": 222, + "ticks": 21 + } + ] + }, + { + "id": 172, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 110, + "columnNumber": 70743 + }, + "hitCount": 26, + "positionTicks": [ + { + "line": 111, + "ticks": 1 + }, + { + "line": 111, + "ticks": 25 + } + ] + }, + { + "id": 175, + "callFrame": { + "functionName": "fetchAndSet", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 4450 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 228, + "ticks": 1 + } + ] + }, + { + "id": 215, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 119960 + }, + "hitCount": 0, + "children": [ + 216, + 230, + 352 + ] + }, + { + "id": 216, + "callFrame": { + "functionName": "alloc", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86148 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 230, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 231 + ] + }, + { + "id": 231, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 232 + ] + }, + { + "id": 232, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 4, + "children": [ + 233 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 4 + } + ] + }, + { + "id": 233, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 5, + "positionTicks": [ + { + "line": 2, + "ticks": 5 + } + ] + }, + { + "id": 352, + "callFrame": { + "functionName": "serializeReplyOK", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 126042 + }, + "hitCount": 0, + "children": [ + 353, + 492 + ] + }, + { + "id": 353, + "callFrame": { + "functionName": "hv", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116413 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 29, + "ticks": 2 + } + ] + }, + { + "id": 492, + "callFrame": { + "functionName": "f", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 126462 + }, + "hitCount": 0, + "children": [ + 493 + ] + }, + { + "id": 493, + "callFrame": { + "functionName": "fromString", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 86344 + }, + "hitCount": 0, + "children": [ + 494 + ] + }, + { + "id": 494, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 495 + ] + }, + { + "id": 495, + "callFrame": { + "functionName": "fromString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 479, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 496 + ] + }, + { + "id": 496, + "callFrame": { + "functionName": "fromStringFast", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 446, + "columnNumber": 23 + }, + "hitCount": 0, + "children": [ + 497 + ] + }, + { + "id": 497, + "callFrame": { + "functionName": "createPool", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 154, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 498 + ] + }, + { + "id": 498, + "callFrame": { + "functionName": "createUnsafeBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 1093, + "columnNumber": 27 + }, + "hitCount": 0, + "children": [ + 499 + ] + }, + { + "id": 499, + "callFrame": { + "functionName": "FastBuffer", + "scriptId": "25", + "url": "node:internal/buffer", + "lineNumber": 959, + "columnNumber": 13 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 961, + "ticks": 1 + } + ] + }, + { + "id": 217, + "callFrame": { + "functionName": "_triggerOnFileChange", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 14428 + }, + "hitCount": 1, + "children": [ + 218, + 221 + ], + "positionTicks": [ + { + "line": 3844, + "ticks": 1 + } + ] + }, + { + "id": 218, + "callFrame": { + "functionName": "match", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 966, + "columnNumber": 1682 + }, + "hitCount": 0, + "children": [ + 219, + 308 + ] + }, + { + "id": 219, + "callFrame": { + "functionName": "matchOne", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 17158 + }, + "hitCount": 2, + "children": [ + 220 + ], + "positionTicks": [ + { + "line": 966, + "ticks": 1 + }, + { + "line": 966, + "ticks": 1 + } + ] + }, + { + "id": 220, + "callFrame": { + "functionName": "matchOne", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 17158 + }, + "hitCount": 2, + "children": [ + 748 + ], + "positionTicks": [ + { + "line": 967, + "ticks": 2 + } + ] + }, + { + "id": 748, + "callFrame": { + "functionName": "RegExp: ^node_modules$", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1 + }, + { + "id": 308, + "callFrame": { + "functionName": "slashSplit", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 966, + "columnNumber": 1548 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 967, + "ticks": 2 + }, + { + "line": 967, + "ticks": 1 + } + ] + }, + { + "id": 221, + "callFrame": { + "functionName": "iT", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 12586 + }, + "hitCount": 1, + "children": [ + 222 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 222, + "callFrame": { + "functionName": "make", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 13393 + }, + "hitCount": 2, + "children": [ + 223, + 302, + 569 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 2 + } + ] + }, + { + "id": 223, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 13815 + }, + "hitCount": 0, + "children": [ + 224 + ] + }, + { + "id": 224, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 14100 + }, + "hitCount": 1, + "children": [ + 225 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 225, + "callFrame": { + "functionName": "parse", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 966, + "columnNumber": 331 + }, + "hitCount": 1, + "children": [ + 226, + 501, + 571 + ], + "positionTicks": [ + { + "line": 967, + "ticks": 1 + } + ] + }, + { + "id": 226, + "callFrame": { + "functionName": "toMMPattern", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 6863 + }, + "hitCount": 11, + "children": [ + 237, + 356, + 747 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 9 + }, + { + "line": 965, + "ticks": 2 + } + ] + }, + { + "id": 237, + "callFrame": { + "functionName": "toRegExpSource", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 7216 + }, + "hitCount": 7, + "children": [ + 304, + 765 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 7 + } + ] + }, + { + "id": 304, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 7333 + }, + "hitCount": 1, + "children": [ + 305 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 305, + "callFrame": { + "functionName": "#m", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 8688 + }, + "hitCount": 0, + "children": [ + 306, + 575 + ] + }, + { + "id": 306, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 3799 + }, + "hitCount": 6, + "positionTicks": [ + { + "line": 965, + "ticks": 6 + } + ] + }, + { + "id": 575, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 3438 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 765, + "callFrame": { + "functionName": "#m", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 8688 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 356, + "callFrame": { + "functionName": "isEnd", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 5507 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 747, + "callFrame": { + "functionName": "isStart", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 5308 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 501, + "callFrame": { + "functionName": "#A", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 5832 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 571, + "callFrame": { + "functionName": "fromGlob", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 6793 + }, + "hitCount": 1, + "children": [ + 572 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 572, + "callFrame": { + "functionName": "#A", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 5832 + }, + "hitCount": 0, + "children": [ + 573 + ] + }, + { + "id": 573, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 3639 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 302, + "callFrame": { + "functionName": "preprocess", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 14411 + }, + "hitCount": 0, + "children": [ + 303 + ] + }, + { + "id": 303, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 14906 + }, + "hitCount": 1, + "children": [ + 511 + ], + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 511, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 14921 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 569, + "callFrame": { + "functionName": "", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 13693 + }, + "hitCount": 0, + "children": [ + 570 + ] + }, + { + "id": 570, + "callFrame": { + "functionName": "slashSplit", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 966, + "columnNumber": 1548 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 967, + "ticks": 1 + } + ] + }, + { + "id": 246, + "callFrame": { + "functionName": "flushStdio", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 315, + "columnNumber": 19 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 316, + "ticks": 1 + } + ] + }, + { + "id": 255, + "callFrame": { + "functionName": "updateWhenIdleAndWait", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 603492 + }, + "hitCount": 0, + "children": [ + 256 + ] + }, + { + "id": 256, + "callFrame": { + "functionName": "o", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 231389 + }, + "hitCount": 0, + "children": [ + 257 + ] + }, + { + "id": 257, + "callFrame": { + "functionName": "status", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 574719 + }, + "hitCount": 0, + "children": [ + 258 + ] + }, + { + "id": 258, + "callFrame": { + "functionName": "run", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 595043 + }, + "hitCount": 0, + "children": [ + 259 + ] + }, + { + "id": 259, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 260 + ] + }, + { + "id": 260, + "callFrame": { + "functionName": "D", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2397 + }, + "hitCount": 0, + "children": [ + 261 + ] + }, + { + "id": 261, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 262 + ] + }, + { + "id": 262, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610351 + }, + "hitCount": 0, + "children": [ + 263, + 592 + ] + }, + { + "id": 263, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 178339 + }, + "hitCount": 0, + "children": [ + 264 + ] + }, + { + "id": 264, + "callFrame": { + "functionName": "f", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 178103 + }, + "hitCount": 0, + "children": [ + 265 + ] + }, + { + "id": 265, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 0, + "children": [ + 266 + ] + }, + { + "id": 266, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 0, + "children": [ + 267 + ] + }, + { + "id": 267, + "callFrame": { + "functionName": "h", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 41255 + }, + "hitCount": 0, + "children": [ + 268 + ] + }, + { + "id": 268, + "callFrame": { + "functionName": "i.registerCommand.description", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 39691 + }, + "hitCount": 0, + "children": [ + 269 + ] + }, + { + "id": 269, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 0, + "children": [ + 270 + ] + }, + { + "id": 270, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 0, + "children": [ + 271 + ] + }, + { + "id": 271, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 272 + ] + }, + { + "id": 272, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 273 + ] + }, + { + "id": 273, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 274 + ] + }, + { + "id": 274, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 275 + ] + }, + { + "id": 275, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 592, + "callFrame": { + "functionName": "onDidChangeOperations", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 127946 + }, + "hitCount": 0, + "children": [ + 593 + ] + }, + { + "id": 593, + "callFrame": { + "functionName": "set state", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 127023 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 276, + "callFrame": { + "functionName": "run", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 595043 + }, + "hitCount": 0, + "children": [ + 277, + 280, + 450 + ] + }, + { + "id": 277, + "callFrame": { + "functionName": "optimisticUpdateEnabled", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 605802 + }, + "hitCount": 0, + "children": [ + 278 + ] + }, + { + "id": 278, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 122133 + }, + "hitCount": 0, + "children": [ + 279 + ] + }, + { + "id": 279, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 280, + "callFrame": { + "functionName": "updateModelState", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 596129 + }, + "hitCount": 0, + "children": [ + 281 + ] + }, + { + "id": 281, + "callFrame": { + "functionName": "_updateModelState", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 596369 + }, + "hitCount": 0, + "children": [ + 282 + ] + }, + { + "id": 282, + "callFrame": { + "functionName": "getWorktrees", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 62627 + }, + "hitCount": 0, + "children": [ + 283 + ] + }, + { + "id": 283, + "callFrame": { + "functionName": "getWorktreesFS", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 62685 + }, + "hitCount": 0, + "children": [ + 284 + ] + }, + { + "id": 284, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 122133 + }, + "hitCount": 0, + "children": [ + 285 + ] + }, + { + "id": 285, + "callFrame": { + "functionName": "getConfiguration", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3183 + }, + "hitCount": 0, + "children": [ + 286 + ] + }, + { + "id": 286, + "callFrame": { + "functionName": "Rs", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24920 + }, + "hitCount": 0, + "children": [ + 287 + ] + }, + { + "id": 287, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 24975 + }, + "hitCount": 0, + "children": [ + 288 + ] + }, + { + "id": 288, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 5034 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 450, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 451 + ] + }, + { + "id": 451, + "callFrame": { + "functionName": "D", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2397 + }, + "hitCount": 0, + "children": [ + 452 + ] + }, + { + "id": 452, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 453 + ] + }, + { + "id": 453, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610195 + }, + "hitCount": 0, + "children": [ + 454 + ] + }, + { + "id": 454, + "callFrame": { + "functionName": "o", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 231389 + }, + "hitCount": 0, + "children": [ + 455 + ] + }, + { + "id": 455, + "callFrame": { + "functionName": "onDidRunWriteOperation", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 623406 + }, + "hitCount": 1, + "children": [ + 670 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 670, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 671 + ] + }, + { + "id": 671, + "callFrame": { + "functionName": "D", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2397 + }, + "hitCount": 0, + "children": [ + 672 + ] + }, + { + "id": 672, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 673 + ] + }, + { + "id": 673, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 48725 + }, + "hitCount": 0, + "children": [ + 674 + ] + }, + { + "id": 674, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 291, + "callFrame": { + "functionName": "re", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8649 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 228, + "ticks": 2 + } + ] + }, + { + "id": 314, + "callFrame": { + "functionName": "readFile", + "scriptId": "84", + "url": "node:internal/fs/promises", + "lineNumber": 1241, + "columnNumber": 23 + }, + "hitCount": 0, + "children": [ + 315 + ] + }, + { + "id": 315, + "callFrame": { + "functionName": "readFileHandle", + "scriptId": "84", + "url": "node:internal/fs/promises", + "lineNumber": 514, + "columnNumber": 29 + }, + "hitCount": 1, + "children": [ + 316 + ], + "positionTicks": [ + { + "line": 523, + "ticks": 1 + } + ] + }, + { + "id": 316, + "callFrame": { + "functionName": "fstat", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 523, + "ticks": 1 + } + ] + }, + { + "id": 317, + "callFrame": { + "functionName": "getInputTemplate", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 573867 + }, + "hitCount": 0, + "children": [ + 318 + ] + }, + { + "id": 318, + "callFrame": { + "functionName": "getCommitTemplate", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 66557 + }, + "hitCount": 0, + "children": [ + 319 + ] + }, + { + "id": 319, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 39865 + }, + "hitCount": 0, + "children": [ + 320 + ] + }, + { + "id": 320, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34010 + }, + "hitCount": 0, + "children": [ + 321 + ] + }, + { + "id": 321, + "callFrame": { + "functionName": "_exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34356 + }, + "hitCount": 0, + "children": [ + 322 + ] + }, + { + "id": 322, + "callFrame": { + "functionName": "spawn", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 35087 + }, + "hitCount": 0, + "children": [ + 323, + 324 + ] + }, + { + "id": 323, + "callFrame": { + "functionName": "t.assign", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610649 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 2, + "ticks": 2 + } + ] + }, + { + "id": 324, + "callFrame": { + "functionName": "spawn", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 810, + "columnNumber": 14 + }, + "hitCount": 0, + "children": [ + 325 + ] + }, + { + "id": 325, + "callFrame": { + "functionName": "spawn", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 353, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 326 + ] + }, + { + "id": 326, + "callFrame": { + "functionName": "spawn", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 395, + "ticks": 3 + } + ] + }, + { + "id": 327, + "callFrame": { + "functionName": "processTicksAndRejections", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 71, + "columnNumber": 34 + }, + "hitCount": 5, + "children": [ + 328, + 406, + 414, + 529, + 550, + 588, + 589, + 591 + ], + "positionTicks": [ + { + "line": 106, + "ticks": 1 + }, + { + "line": 72, + "ticks": 1 + }, + { + "line": 565, + "ticks": 1 + }, + { + "line": 57, + "ticks": 1 + }, + { + "line": 541, + "ticks": 1 + } + ] + }, + { + "id": 328, + "callFrame": { + "functionName": "finish", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 948, + "columnNumber": 15 + }, + "hitCount": 0, + "children": [ + 329 + ] + }, + { + "id": 329, + "callFrame": { + "functionName": "Writable.destroy", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 1113, + "columnNumber": 37 + }, + "hitCount": 0, + "children": [ + 330 + ] + }, + { + "id": 330, + "callFrame": { + "functionName": "destroy", + "scriptId": "101", + "url": "node:internal/streams/destroy", + "lineNumber": 48, + "columnNumber": 16 + }, + "hitCount": 0, + "children": [ + 331 + ] + }, + { + "id": 331, + "callFrame": { + "functionName": "Socket._destroy", + "scriptId": "94", + "url": "node:net", + "lineNumber": 807, + "columnNumber": 36 + }, + "hitCount": 0, + "children": [ + 332, + 583, + 766 + ] + }, + { + "id": 332, + "callFrame": { + "functionName": "close", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 4, + "positionTicks": [ + { + "line": 808, + "ticks": 4 + } + ] + }, + { + "id": 583, + "callFrame": { + "functionName": "getStderr", + "scriptId": "63", + "url": "node:internal/bootstrap/switches/is_main_thread", + "lineNumber": 172, + "columnNumber": 18 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 173, + "ticks": 1 + } + ] + }, + { + "id": 766, + "callFrame": { + "functionName": "onDestroy", + "scriptId": "101", + "url": "node:internal/streams/destroy", + "lineNumber": 92, + "columnNumber": 20 + }, + "hitCount": 0, + "children": [ + 767 + ] + }, + { + "id": 767, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 768 + ] + }, + { + "id": 768, + "callFrame": { + "functionName": "nextTick", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 112, + "columnNumber": 17 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 137, + "ticks": 1 + } + ] + }, + { + "id": 406, + "callFrame": { + "functionName": "maybeReadMore_", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 863, + "columnNumber": 23 + }, + "hitCount": 3, + "children": [ + 407 + ], + "positionTicks": [ + { + "line": 893, + "ticks": 3 + } + ] + }, + { + "id": 407, + "callFrame": { + "functionName": "Socket.read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 779, + "columnNumber": 32 + }, + "hitCount": 3, + "children": [ + 512 + ], + "positionTicks": [ + { + "line": 785, + "ticks": 3 + } + ] + }, + { + "id": 512, + "callFrame": { + "functionName": "Readable.read", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 646, + "columnNumber": 34 + }, + "hitCount": 6, + "children": [ + 513 + ], + "positionTicks": [ + { + "line": 785, + "ticks": 1 + }, + { + "line": 739, + "ticks": 1 + }, + { + "line": 670, + "ticks": 1 + }, + { + "line": 748, + "ticks": 1 + }, + { + "line": 729, + "ticks": 1 + }, + { + "line": 641, + "ticks": 1 + } + ] + }, + { + "id": 513, + "callFrame": { + "functionName": "Socket._read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 719, + "columnNumber": 33 + }, + "hitCount": 0, + "children": [ + 514 + ] + }, + { + "id": 514, + "callFrame": { + "functionName": "get", + "scriptId": "94", + "url": "node:net", + "lineNumber": 2445, + "columnNumber": 5 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 2446, + "ticks": 2 + } + ] + }, + { + "id": 414, + "callFrame": { + "functionName": "processPromiseRejections", + "scriptId": "31", + "url": "node:internal/process/promises", + "lineNumber": 438, + "columnNumber": 33 + }, + "hitCount": 5, + "children": [ + 415 + ], + "positionTicks": [ + { + "line": 439, + "ticks": 5 + } + ] + }, + { + "id": 415, + "callFrame": { + "functionName": "SafeMap", + "scriptId": "3", + "url": "node:internal/per_context/primordials", + "lineNumber": 408, + "columnNumber": 15 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 409, + "ticks": 3 + } + ] + }, + { + "id": 529, + "callFrame": { + "functionName": "endWritableNT", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1719, + "columnNumber": 22 + }, + "hitCount": 0, + "children": [ + 530, + 545 + ] + }, + { + "id": 530, + "callFrame": { + "functionName": "Writable.end", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 807, + "columnNumber": 33 + }, + "hitCount": 0, + "children": [ + 531 + ] + }, + { + "id": 531, + "callFrame": { + "functionName": "prefinish", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 905, + "columnNumber": 18 + }, + "hitCount": 1, + "children": [ + 532 + ], + "positionTicks": [ + { + "line": 916, + "ticks": 1 + } + ] + }, + { + "id": 532, + "callFrame": { + "functionName": "Socket._final", + "scriptId": "94", + "url": "node:net", + "lineNumber": 529, + "columnNumber": 34 + }, + "hitCount": 1, + "children": [ + 533 + ], + "positionTicks": [ + { + "line": 542, + "ticks": 1 + } + ] + }, + { + "id": 533, + "callFrame": { + "functionName": "shutdown", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 546, + "ticks": 3 + } + ] + }, + { + "id": 545, + "callFrame": { + "functionName": "prefinish", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 905, + "columnNumber": 18 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 906, + "ticks": 1 + } + ] + }, + { + "id": 550, + "callFrame": { + "functionName": "flushStdio", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 315, + "columnNumber": 19 + }, + "hitCount": 2, + "children": [ + 581 + ], + "positionTicks": [ + { + "line": 316, + "ticks": 2 + } + ] + }, + { + "id": 581, + "callFrame": { + "functionName": "get", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1414, + "columnNumber": 7 + }, + "hitCount": 0, + "children": [ + 582 + ] + }, + { + "id": 582, + "callFrame": { + "functionName": "get", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 131, + "columnNumber": 7 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 132, + "ticks": 1 + } + ] + }, + { + "id": 588, + "callFrame": { + "functionName": "Socket.read", + "scriptId": "94", + "url": "node:net", + "lineNumber": 779, + "columnNumber": 32 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 780, + "ticks": 1 + } + ] + }, + { + "id": 589, + "callFrame": { + "functionName": "runMicrotasks", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 2, + "children": [ + 646 + ], + "positionTicks": [ + { + "line": 105, + "ticks": 2 + } + ] + }, + { + "id": 646, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 2580 + }, + "hitCount": 0, + "children": [ + 647 + ] + }, + { + "id": 647, + "callFrame": { + "functionName": "appendLine", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 465 + }, + "hitCount": 0, + "children": [ + 648 + ] + }, + { + "id": 648, + "callFrame": { + "functionName": "info", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 15354 + }, + "hitCount": 0, + "children": [ + 649 + ] + }, + { + "id": 649, + "callFrame": { + "functionName": "m", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 312 + }, + "hitCount": 0, + "children": [ + 650 + ] + }, + { + "id": 650, + "callFrame": { + "functionName": "sO", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 14445 + }, + "hitCount": 0, + "children": [ + 651 + ] + }, + { + "id": 651, + "callFrame": { + "functionName": "info", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 15354 + }, + "hitCount": 0, + "children": [ + 652 + ] + }, + { + "id": 652, + "callFrame": { + "functionName": "m", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 249, + "columnNumber": 9016 + }, + "hitCount": 0, + "children": [ + 653 + ] + }, + { + "id": 653, + "callFrame": { + "functionName": "JP", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 249, + "columnNumber": 8127 + }, + "hitCount": 0, + "children": [ + 654 + ] + }, + { + "id": 654, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 250, + "ticks": 1 + } + ] + }, + { + "id": 591, + "callFrame": { + "functionName": "SafeMap", + "scriptId": "3", + "url": "node:internal/per_context/primordials", + "lineNumber": 408, + "columnNumber": 15 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 409, + "ticks": 1 + } + ] + }, + { + "id": 334, + "callFrame": { + "functionName": "getRemotesFS", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 63812 + }, + "hitCount": 0, + "children": [ + 335 + ] + }, + { + "id": 335, + "callFrame": { + "functionName": "O", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 37253 + }, + "hitCount": 0, + "children": [ + 336 + ] + }, + { + "id": 336, + "callFrame": { + "functionName": "parse", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 36098 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 337, + "callFrame": { + "functionName": "getHEADRef", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 58588 + }, + "hitCount": 0, + "children": [ + 338 + ] + }, + { + "id": 338, + "callFrame": { + "functionName": "getRefs", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 60309 + }, + "hitCount": 0, + "children": [ + 339 + ] + }, + { + "id": 339, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 39865 + }, + "hitCount": 0, + "children": [ + 340 + ] + }, + { + "id": 340, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34010 + }, + "hitCount": 0, + "children": [ + 341 + ] + }, + { + "id": 341, + "callFrame": { + "functionName": "_exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34356 + }, + "hitCount": 0, + "children": [ + 342 + ] + }, + { + "id": 342, + "callFrame": { + "functionName": "spawn", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 35087 + }, + "hitCount": 0, + "children": [ + 343 + ] + }, + { + "id": 343, + "callFrame": { + "functionName": "spawn", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 810, + "columnNumber": 14 + }, + "hitCount": 1, + "children": [ + 344 + ], + "positionTicks": [ + { + "line": 812, + "ticks": 1 + } + ] + }, + { + "id": 344, + "callFrame": { + "functionName": "spawn", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 353, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 345 + ] + }, + { + "id": 345, + "callFrame": { + "functionName": "spawn", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 395, + "ticks": 2 + } + ] + }, + { + "id": 346, + "callFrame": { + "functionName": "resume_", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 1253, + "columnNumber": 16 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 1254, + "ticks": 1 + } + ] + }, + { + "id": 347, + "callFrame": { + "functionName": "ChildProcess._handle.onexit", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 268, + "columnNumber": 24 + }, + "hitCount": 0, + "children": [ + 348 + ] + }, + { + "id": 348, + "callFrame": { + "functionName": "Writable.destroy", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 1113, + "columnNumber": 37 + }, + "hitCount": 0, + "children": [ + 349 + ] + }, + { + "id": 349, + "callFrame": { + "functionName": "destroy", + "scriptId": "101", + "url": "node:internal/streams/destroy", + "lineNumber": 48, + "columnNumber": 16 + }, + "hitCount": 1, + "children": [ + 350 + ], + "positionTicks": [ + { + "line": 49, + "ticks": 1 + } + ] + }, + { + "id": 350, + "callFrame": { + "functionName": "Socket._destroy", + "scriptId": "94", + "url": "node:net", + "lineNumber": 807, + "columnNumber": 36 + }, + "hitCount": 1, + "children": [ + 378, + 554 + ], + "positionTicks": [ + { + "line": 808, + "ticks": 1 + } + ] + }, + { + "id": 378, + "callFrame": { + "functionName": "close", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 808, + "ticks": 3 + } + ] + }, + { + "id": 554, + "callFrame": { + "functionName": "getStderr", + "scriptId": "63", + "url": "node:internal/bootstrap/switches/is_main_thread", + "lineNumber": 172, + "columnNumber": 18 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 173, + "ticks": 2 + } + ] + }, + { + "id": 354, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 234, + "columnNumber": 918 + }, + "hitCount": 11, + "positionTicks": [ + { + "line": 235, + "ticks": 11 + } + ] + }, + { + "id": 355, + "callFrame": { + "functionName": "", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 227, + "columnNumber": 8258 + }, + "hitCount": 4, + "children": [ + 568 + ], + "positionTicks": [ + { + "line": 228, + "ticks": 2 + }, + { + "line": 228, + "ticks": 2 + } + ] + }, + { + "id": 568, + "callFrame": { + "functionName": "isMatch", + "scriptId": "420", + "url": "piiRemoved/extension-node.js", + "lineNumber": 234, + "columnNumber": 823 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 235, + "ticks": 2 + } + ] + }, + { + "id": 394, + "callFrame": { + "functionName": "getStatus", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 597655 + }, + "hitCount": 1, + "children": [ + 395 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 395, + "callFrame": { + "functionName": "get validateInput", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 44285 + }, + "hitCount": 0, + "children": [ + 396 + ] + }, + { + "id": 396, + "callFrame": { + "functionName": "T", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 107, + "columnNumber": 33239 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 108, + "ticks": 1 + } + ] + }, + { + "id": 397, + "callFrame": { + "functionName": "file", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 57791 + }, + "hitCount": 3, + "positionTicks": [ + { + "line": 28, + "ticks": 3 + } + ] + }, + { + "id": 398, + "callFrame": { + "functionName": "afterShutdown", + "scriptId": "94", + "url": "node:net", + "lineNumber": 553, + "columnNumber": 22 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 559, + "ticks": 1 + } + ] + }, + { + "id": 423, + "callFrame": { + "functionName": "_exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34356 + }, + "hitCount": 0, + "children": [ + 424, + 596, + 597 + ] + }, + { + "id": 424, + "callFrame": { + "functionName": "toString", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 834, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 425 + ] + }, + { + "id": 425, + "callFrame": { + "functionName": "slice", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 635, + "columnNumber": 11 + }, + "hitCount": 6, + "children": [ + 608 + ], + "positionTicks": [ + { + "line": 636, + "ticks": 6 + } + ] + }, + { + "id": 608, + "callFrame": { + "functionName": "utf8Slice", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 636, + "ticks": 1 + } + ] + }, + { + "id": 596, + "callFrame": { + "functionName": "P", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 29411 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 597, + "callFrame": { + "functionName": "D", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 28956 + }, + "hitCount": 0, + "children": [ + 598 + ] + }, + { + "id": 598, + "callFrame": { + "functionName": "D", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 28884 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 426, + "callFrame": { + "functionName": "getRefs", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 60309 + }, + "hitCount": 2, + "children": [ + 427 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 2 + } + ] + }, + { + "id": 427, + "callFrame": { + "functionName": "exec.cancellationToken", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 60849 + }, + "hitCount": 7, + "positionTicks": [ + { + "line": 2, + "ticks": 4 + }, + { + "line": 2, + "ticks": 1 + }, + { + "line": 2, + "ticks": 1 + }, + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 428, + "callFrame": { + "functionName": "_updateModelState", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 596369 + }, + "hitCount": 1, + "children": [ + 429, + 609, + 622 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 429, + "callFrame": { + "functionName": "fire", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2476 + }, + "hitCount": 0, + "children": [ + 430 + ] + }, + { + "id": 430, + "callFrame": { + "functionName": "D", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2397 + }, + "hitCount": 0, + "children": [ + 431 + ] + }, + { + "id": 431, + "callFrame": { + "functionName": "C", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2286 + }, + "hitCount": 0, + "children": [ + 432, + 447, + 661 + ] + }, + { + "id": 432, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 177998 + }, + "hitCount": 0, + "children": [ + 433 + ] + }, + { + "id": 433, + "callFrame": { + "functionName": "onDidChangeActiveTextEditor", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 170949 + }, + "hitCount": 0, + "children": [ + 434 + ] + }, + { + "id": 434, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 105051 + }, + "hitCount": 0, + "children": [ + 435 + ] + }, + { + "id": 435, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 0, + "children": [ + 436 + ] + }, + { + "id": 436, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 0, + "children": [ + 437 + ] + }, + { + "id": 437, + "callFrame": { + "functionName": "h", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 41255 + }, + "hitCount": 0, + "children": [ + 438 + ] + }, + { + "id": 438, + "callFrame": { + "functionName": "i.registerCommand.description", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 39691 + }, + "hitCount": 0, + "children": [ + 439 + ] + }, + { + "id": 439, + "callFrame": { + "functionName": "executeCommand", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40534 + }, + "hitCount": 0, + "children": [ + 440 + ] + }, + { + "id": 440, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 0, + "children": [ + 441 + ] + }, + { + "id": 441, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 442 + ] + }, + { + "id": 442, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 443 + ] + }, + { + "id": 443, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 444 + ] + }, + { + "id": 444, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 445 + ] + }, + { + "id": 445, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 446 + ] + }, + { + "id": 446, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 447, + "callFrame": { + "functionName": "", + "scriptId": "752", + "url": "piiRemoved/extension.js", + "lineNumber": 3144, + "columnNumber": 15453 + }, + "hitCount": 0, + "children": [ + 448 + ] + }, + { + "id": 448, + "callFrame": { + "functionName": "e", + "scriptId": "752", + "url": "piiRemoved/extension.js", + "lineNumber": 3144, + "columnNumber": 14859 + }, + "hitCount": 0, + "children": [ + 449 + ] + }, + { + "id": 449, + "callFrame": { + "functionName": "getOrCreateSingleRepoState", + "scriptId": "752", + "url": "piiRemoved/extension.js", + "lineNumber": 3144, + "columnNumber": 14073 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3145, + "ticks": 1 + } + ] + }, + { + "id": 661, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 567969 + }, + "hitCount": 0, + "children": [ + 662 + ] + }, + { + "id": 662, + "callFrame": { + "functionName": "updateInputBoxPlaceholder", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 605118 + }, + "hitCount": 0, + "children": [ + 663 + ] + }, + { + "id": 663, + "callFrame": { + "functionName": "set placeholder", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 200, + "columnNumber": 44213 + }, + "hitCount": 0, + "children": [ + 664 + ] + }, + { + "id": 664, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 665 + ] + }, + { + "id": 665, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 666 + ] + }, + { + "id": 666, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 667 + ] + }, + { + "id": 667, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 668 + ] + }, + { + "id": 668, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 669 + ] + }, + { + "id": 669, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 609, + "callFrame": { + "functionName": "getStatus", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 597655 + }, + "hitCount": 0, + "children": [ + 610, + 612 + ] + }, + { + "id": 610, + "callFrame": { + "functionName": "get", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 3501 + }, + "hitCount": 0, + "children": [ + 611 + ] + }, + { + "id": 611, + "callFrame": { + "functionName": "Eg", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 1739 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 612, + "callFrame": { + "functionName": "getStatus", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 57160 + }, + "hitCount": 0, + "children": [ + 613 + ] + }, + { + "id": 613, + "callFrame": { + "functionName": "stream", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 39932 + }, + "hitCount": 1, + "children": [ + 614 + ], + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 614, + "callFrame": { + "functionName": "stream", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34135 + }, + "hitCount": 0, + "children": [ + 615 + ] + }, + { + "id": 615, + "callFrame": { + "functionName": "spawn", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 35087 + }, + "hitCount": 0, + "children": [ + 616, + 617 + ] + }, + { + "id": 616, + "callFrame": { + "functionName": "t.assign", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 610649 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 617, + "callFrame": { + "functionName": "spawn", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 810, + "columnNumber": 14 + }, + "hitCount": 0, + "children": [ + 618 + ] + }, + { + "id": 618, + "callFrame": { + "functionName": "spawn", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 353, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 619, + 620 + ] + }, + { + "id": 619, + "callFrame": { + "functionName": "spawn", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 395, + "ticks": 2 + } + ] + }, + { + "id": 620, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 621 + ] + }, + { + "id": 621, + "callFrame": { + "functionName": "nextTick", + "scriptId": "30", + "url": "node:internal/process/task_queues", + "lineNumber": 112, + "columnNumber": 17 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 137, + "ticks": 1 + }, + { + "line": 113, + "ticks": 1 + } + ] + }, + { + "id": 622, + "callFrame": { + "functionName": "getRefs", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 584792 + }, + "hitCount": 0, + "children": [ + 623 + ] + }, + { + "id": 623, + "callFrame": { + "functionName": "run", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 595043 + }, + "hitCount": 0, + "children": [ + 624 + ] + }, + { + "id": 624, + "callFrame": { + "functionName": "retryRun", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 595563 + }, + "hitCount": 0, + "children": [ + 625 + ] + }, + { + "id": 625, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 584996 + }, + "hitCount": 0, + "children": [ + 626 + ] + }, + { + "id": 626, + "callFrame": { + "functionName": "getRefs", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 60309 + }, + "hitCount": 0, + "children": [ + 627 + ] + }, + { + "id": 627, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 39865 + }, + "hitCount": 0, + "children": [ + 628 + ] + }, + { + "id": 628, + "callFrame": { + "functionName": "exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34010 + }, + "hitCount": 0, + "children": [ + 629 + ] + }, + { + "id": 629, + "callFrame": { + "functionName": "_exec", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 34356 + }, + "hitCount": 0, + "children": [ + 630, + 634 + ] + }, + { + "id": 630, + "callFrame": { + "functionName": "spawn", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 35087 + }, + "hitCount": 0, + "children": [ + 631 + ] + }, + { + "id": 631, + "callFrame": { + "functionName": "spawn", + "scriptId": "92", + "url": "node:child_process", + "lineNumber": 810, + "columnNumber": 14 + }, + "hitCount": 0, + "children": [ + 632 + ] + }, + { + "id": 632, + "callFrame": { + "functionName": "spawn", + "scriptId": "93", + "url": "node:internal/child_process", + "lineNumber": 353, + "columnNumber": 45 + }, + "hitCount": 0, + "children": [ + 633 + ] + }, + { + "id": 633, + "callFrame": { + "functionName": "spawn", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 395, + "ticks": 1 + } + ] + }, + { + "id": 634, + "callFrame": { + "functionName": "E", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 27981 + }, + "hitCount": 0, + "children": [ + 635 + ] + }, + { + "id": 635, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 28642 + }, + "hitCount": 0, + "children": [ + 636, + 638 + ] + }, + { + "id": 636, + "callFrame": { + "functionName": "get onCancellationRequested", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 5207 + }, + "hitCount": 0, + "children": [ + 637 + ] + }, + { + "id": 637, + "callFrame": { + "functionName": "get event", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 829 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 638, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 615763 + }, + "hitCount": 0, + "children": [ + 639 + ] + }, + { + "id": 639, + "callFrame": { + "functionName": "u", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 848 + }, + "hitCount": 0, + "children": [ + 640 + ] + }, + { + "id": 640, + "callFrame": { + "functionName": "N2", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 26, + "columnNumber": 2732 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 27, + "ticks": 1 + } + ] + }, + { + "id": 470, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 4527 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 121, + "ticks": 1 + } + ] + }, + { + "id": 473, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 115, + "columnNumber": 11211 + }, + "hitCount": 0, + "children": [ + 474 + ] + }, + { + "id": 474, + "callFrame": { + "functionName": "n", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 115, + "columnNumber": 11064 + }, + "hitCount": 0, + "children": [ + 475 + ] + }, + { + "id": 475, + "callFrame": { + "functionName": "s..n.charCodeAt.s.", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 118481 + }, + "hitCount": 0, + "children": [ + 476 + ] + }, + { + "id": 476, + "callFrame": { + "functionName": "U", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 120975 + }, + "hitCount": 0, + "children": [ + 477 + ] + }, + { + "id": 477, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 8629 + }, + "hitCount": 0, + "children": [ + 478 + ] + }, + { + "id": 478, + "callFrame": { + "functionName": "send", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 392, + "columnNumber": 7023 + }, + "hitCount": 0, + "children": [ + 479 + ] + }, + { + "id": 479, + "callFrame": { + "functionName": "postMessage", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 3054 + }, + "hitCount": 0, + "children": [ + 480 + ] + }, + { + "id": 480, + "callFrame": { + "functionName": "postMessage", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 2, + "ticks": 1 + } + ] + }, + { + "id": 504, + "callFrame": { + "functionName": "_unrefTimer", + "scriptId": "94", + "url": "node:net", + "lineNumber": 519, + "columnNumber": 51 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 520, + "ticks": 1 + } + ] + }, + { + "id": 510, + "callFrame": { + "functionName": "iT", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 12586 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 965, + "ticks": 1 + }, + { + "line": 965, + "ticks": 1 + } + ] + }, + { + "id": 546, + "callFrame": { + "functionName": "readableAddChunkPushByteMode", + "scriptId": "104", + "url": "node:internal/streams/readable", + "lineNumber": 462, + "columnNumber": 37 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 464, + "ticks": 1 + } + ] + }, + { + "id": 557, + "callFrame": { + "functionName": "getIgnoreGlobs", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 3843, + "columnNumber": 13895 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 3844, + "ticks": 1 + } + ] + }, + { + "id": 563, + "callFrame": { + "functionName": "matchOne", + "scriptId": "743", + "url": "piiRemoved/extension.js", + "lineNumber": 964, + "columnNumber": 17158 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 967, + "ticks": 1 + } + ] + }, + { + "id": 564, + "callFrame": { + "functionName": "_poll", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 169, + "columnNumber": 534 + }, + "hitCount": 1, + "children": [ + 565 + ], + "positionTicks": [ + { + "line": 170, + "ticks": 1 + } + ] + }, + { + "id": 565, + "callFrame": { + "functionName": "", + "scriptId": "119", + "url": "node:electron/js2c/utility_init", + "lineNumber": 1, + "columnNumber": 14967 + }, + "hitCount": 0, + "children": [ + 566 + ] + }, + { + "id": 566, + "callFrame": { + "functionName": "setTimeout", + "scriptId": "34", + "url": "node:timers", + "lineNumber": 135, + "columnNumber": 19 + }, + "hitCount": 0, + "children": [ + 567 + ] + }, + { + "id": 567, + "callFrame": { + "functionName": "insert", + "scriptId": "10", + "url": "node:internal/timers", + "lineNumber": 367, + "columnNumber": 15 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 374, + "ticks": 1 + } + ] + }, + { + "id": 579, + "callFrame": { + "functionName": "j", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 141, + "columnNumber": 6345 + }, + "hitCount": 2, + "positionTicks": [ + { + "line": 142, + "ticks": 2 + } + ] + }, + { + "id": 590, + "callFrame": { + "functionName": "toJSON", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 27, + "columnNumber": 59147 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 28, + "ticks": 1 + } + ] + }, + { + "id": 595, + "callFrame": { + "functionName": "g", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 113, + "columnNumber": 40621 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 114, + "ticks": 1 + } + ] + }, + { + "id": 599, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 2580 + }, + "hitCount": 0, + "children": [ + 600 + ] + }, + { + "id": 600, + "callFrame": { + "functionName": "appendLine", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 465 + }, + "hitCount": 0, + "children": [ + 601 + ] + }, + { + "id": 601, + "callFrame": { + "functionName": "info", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 15354 + }, + "hitCount": 0, + "children": [ + 602 + ] + }, + { + "id": 602, + "callFrame": { + "functionName": "m", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 120, + "columnNumber": 312 + }, + "hitCount": 0, + "children": [ + 603 + ] + }, + { + "id": 603, + "callFrame": { + "functionName": "sO", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 14445 + }, + "hitCount": 0, + "children": [ + 604 + ] + }, + { + "id": 604, + "callFrame": { + "functionName": "info", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 31, + "columnNumber": 15354 + }, + "hitCount": 0, + "children": [ + 605 + ] + }, + { + "id": 605, + "callFrame": { + "functionName": "m", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 249, + "columnNumber": 9016 + }, + "hitCount": 0, + "children": [ + 606 + ] + }, + { + "id": 606, + "callFrame": { + "functionName": "JP", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 249, + "columnNumber": 8127 + }, + "hitCount": 0, + "children": [ + 607 + ] + }, + { + "id": 607, + "callFrame": { + "functionName": "", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 250, + "ticks": 1 + } + ] + }, + { + "id": 641, + "callFrame": { + "functionName": "then", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 116219 + }, + "hitCount": 0, + "children": [ + 642 + ] + }, + { + "id": 642, + "callFrame": { + "functionName": "j", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 115953 + }, + "hitCount": 0, + "children": [ + 643 + ] + }, + { + "id": 643, + "callFrame": { + "functionName": "", + "scriptId": "147", + "url": "piiRemoved/extensionHostProcess.js", + "lineNumber": 28, + "columnNumber": 115991 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 29, + "ticks": 1 + } + ] + }, + { + "id": 708, + "callFrame": { + "functionName": "", + "scriptId": "806", + "url": "piiRemoved/extension-CXz73ARr.js", + "lineNumber": 0, + "columnNumber": 84752 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 121, + "ticks": 1 + } + ] + }, + { + "id": 712, + "callFrame": { + "functionName": "provideOriginalResource", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 572052 + }, + "hitCount": 0, + "children": [ + 713 + ] + }, + { + "id": 713, + "callFrame": { + "functionName": "", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 572979 + }, + "hitCount": 0, + "children": [ + 714 + ] + }, + { + "id": 714, + "callFrame": { + "functionName": "t.pathEquals", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 612361 + }, + "hitCount": 0, + "children": [ + 715 + ] + }, + { + "id": 715, + "callFrame": { + "functionName": "g", + "scriptId": "606", + "url": "piiRemoved/main.js", + "lineNumber": 1, + "columnNumber": 615963 + }, + "hitCount": 0, + "children": [ + 716 + ] + }, + { + "id": 716, + "callFrame": { + "functionName": "normalize", + "scriptId": "36", + "url": "node:path", + "lineNumber": 1253, + "columnNumber": 11 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 94, + "ticks": 1 + } + ] + }, + { + "id": 717, + "callFrame": { + "functionName": "_sendMessage", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 106, + "columnNumber": 12750 + }, + "hitCount": 0, + "children": [ + 718 + ] + }, + { + "id": 718, + "callFrame": { + "functionName": "send", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 106, + "columnNumber": 11645 + }, + "hitCount": 1, + "children": [ + 719 + ], + "positionTicks": [ + { + "line": 107, + "ticks": 1 + } + ] + }, + { + "id": 719, + "callFrame": { + "functionName": "send", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 37531 + }, + "hitCount": 0, + "children": [ + 720 + ] + }, + { + "id": 720, + "callFrame": { + "functionName": "send", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 26758 + }, + "hitCount": 0, + "children": [ + 721 + ] + }, + { + "id": 721, + "callFrame": { + "functionName": "dispatch", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 27894 + }, + "hitCount": 0, + "children": [ + 722, + 723 + ] + }, + { + "id": 722, + "callFrame": { + "functionName": "from", + "scriptId": "24", + "url": "node:buffer", + "lineNumber": 297, + "columnNumber": 27 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 298, + "ticks": 1 + } + ] + }, + { + "id": 723, + "callFrame": { + "functionName": "sendFrame", + "scriptId": "608", + "url": "piiRemoved/extension.js", + "lineNumber": 2, + "columnNumber": 28494 + }, + "hitCount": 0, + "children": [ + 724 + ] + }, + { + "id": 724, + "callFrame": { + "functionName": "Writable.uncork", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 519, + "columnNumber": 36 + }, + "hitCount": 0, + "children": [ + 725 + ] + }, + { + "id": 725, + "callFrame": { + "functionName": "clearBuffer", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 743, + "columnNumber": 20 + }, + "hitCount": 0, + "children": [ + 726 + ] + }, + { + "id": 726, + "callFrame": { + "functionName": "doWrite", + "scriptId": "108", + "url": "node:internal/streams/writable", + "lineNumber": 586, + "columnNumber": 16 + }, + "hitCount": 0, + "children": [ + 727 + ] + }, + { + "id": 727, + "callFrame": { + "functionName": "Socket._writev", + "scriptId": "94", + "url": "node:net", + "lineNumber": 971, + "columnNumber": 35 + }, + "hitCount": 0, + "children": [ + 728 + ] + }, + { + "id": 728, + "callFrame": { + "functionName": "Socket._writeGeneric", + "scriptId": "94", + "url": "node:net", + "lineNumber": 934, + "columnNumber": 41 + }, + "hitCount": 0, + "children": [ + 729 + ] + }, + { + "id": 729, + "callFrame": { + "functionName": "writevGeneric", + "scriptId": "113", + "url": "node:internal/stream_base_commons", + "lineNumber": 120, + "columnNumber": 22 + }, + "hitCount": 0, + "children": [ + 730 + ] + }, + { + "id": 730, + "callFrame": { + "functionName": "writev", + "scriptId": "0", + "url": "", + "lineNumber": -1, + "columnNumber": -1 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 137, + "ticks": 1 + } + ] + }, + { + "id": 758, + "callFrame": { + "functionName": "processPromiseRejections", + "scriptId": "31", + "url": "node:internal/process/promises", + "lineNumber": 438, + "columnNumber": 33 + }, + "hitCount": 1, + "positionTicks": [ + { + "line": 439, + "ticks": 1 + } + ] + } + ], + "startTime": 341592025292, + "endTime": 341603042126, + "samples": [ + 2, + 2, + 2, + 2, + 2, + 6, + 5, + 6, + 6, + 6, + 7, + 5, + 2, + 4, + 5, + 6, + 5, + 5, + 3, + 6, + 3, + 6, + 6, + 5, + 7, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 5, + 3, + 6, + 5, + 3, + 6, + 7, + 6, + 6, + 6, + 7, + 6, + 5, + 6, + 6, + 5, + 6, + 7, + 5, + 6, + 6, + 7, + 7, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 3, + 5, + 7, + 5, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 7, + 6, + 6, + 5, + 5, + 6, + 6, + 7, + 5, + 7, + 6, + 6, + 4, + 6, + 5, + 5, + 4, + 3, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 7, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 5, + 7, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 7, + 6, + 5, + 5, + 4, + 5, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 2, + 2, + 9, + 9, + 18, + 29, + 34, + 34, + 34, + 37, + 42, + 52, + 24, + 24, + 34, + 34, + 37, + 40, + 55, + 22, + 24, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 26, + 24, + 9, + 34, + 33, + 33, + 34, + 42, + 60, + 24, + 34, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 37, + 42, + 57, + 57, + 9, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 33, + 24, + 37, + 42, + 57, + 24, + 34, + 63, + 34, + 42, + 42, + 55, + 26, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 62, + 24, + 65, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 2, + 24, + 24, + 9, + 24, + 62, + 2, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 24, + 33, + 33, + 34, + 37, + 42, + 56, + 2, + 24, + 34, + 34, + 63, + 42, + 56, + 57, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 24, + 34, + 34, + 68, + 42, + 56, + 57, + 26, + 62, + 34, + 34, + 34, + 42, + 42, + 55, + 9, + 24, + 33, + 34, + 34, + 68, + 42, + 56, + 62, + 9, + 24, + 9, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 2, + 71, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 24, + 23, + 33, + 34, + 34, + 42, + 56, + 55, + 76, + 81, + 91, + 88, + 9, + 111, + 113, + 114, + 111, + 2, + 122, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 140, + 141, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 141, + 140, + 142, + 142, + 142, + 142, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 7, + 6, + 6, + 6, + 4, + 4, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 7, + 6, + 7, + 7, + 6, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 4, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 3, + 7, + 7, + 5, + 5, + 7, + 6, + 6, + 6, + 5, + 7, + 5, + 5, + 6, + 6, + 4, + 6, + 4, + 5, + 5, + 6, + 6, + 7, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 4, + 4, + 5, + 4, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 7, + 7, + 7, + 5, + 6, + 6, + 5, + 7, + 6, + 6, + 5, + 6, + 3, + 5, + 5, + 6, + 5, + 8, + 8, + 8, + 8, + 8, + 2, + 9, + 9, + 9, + 147, + 160, + 160, + 161, + 162, + 166, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 140, + 3, + 6, + 6, + 5, + 5, + 61, + 61, + 61, + 6, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 2, + 2, + 61, + 61, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 135, + 61, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 167, + 141, + 141, + 140, + 140, + 141, + 140, + 169, + 140, + 141, + 140, + 139, + 141, + 139, + 140, + 2, + 3, + 3, + 3, + 3, + 5, + 5, + 6, + 6, + 6, + 6, + 5, + 7, + 170, + 6, + 6, + 7, + 5, + 6, + 6, + 5, + 5, + 7, + 4, + 6, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 6, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 7, + 7, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 6, + 6, + 4, + 5, + 5, + 6, + 7, + 5, + 6, + 7, + 5, + 6, + 7, + 6, + 5, + 6, + 7, + 3, + 5, + 5, + 6, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 4, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 5, + 7, + 5, + 7, + 6, + 5, + 8, + 8, + 8, + 8, + 8, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 169, + 141, + 140, + 2, + 141, + 139, + 2, + 3, + 3, + 6, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 4, + 6, + 5, + 5, + 6, + 6, + 4, + 6, + 5, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 7, + 4, + 5, + 6, + 6, + 6, + 5, + 5, + 7, + 7, + 6, + 6, + 6, + 6, + 7, + 5, + 5, + 5, + 6, + 61, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 6, + 7, + 6, + 5, + 6, + 5, + 5, + 4, + 4, + 5, + 5, + 3, + 5, + 7, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 7, + 6, + 6, + 6, + 7, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 7, + 6, + 5, + 5, + 5, + 6, + 7, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 7, + 6, + 6, + 7, + 2, + 6, + 5, + 5, + 6, + 6, + 5, + 2, + 6, + 7, + 6, + 3, + 5, + 5, + 5, + 5, + 7, + 5, + 8, + 171, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 172, + 172, + 140, + 174, + 172, + 172, + 174, + 174, + 139, + 173, + 174, + 140, + 174, + 174, + 140, + 173, + 174, + 174, + 173, + 174, + 173, + 140, + 174, + 173, + 140, + 174, + 139, + 140, + 142, + 142, + 142, + 3, + 3, + 3, + 5, + 6, + 3, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 4, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 7, + 5, + 4, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 7, + 5, + 5, + 6, + 5, + 6, + 7, + 3, + 2, + 6, + 6, + 7, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 4, + 5, + 6, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 7, + 5, + 4, + 7, + 5, + 6, + 2, + 6, + 5, + 6, + 6, + 4, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 5, + 7, + 7, + 61, + 5, + 5, + 6, + 2, + 5, + 6, + 6, + 5, + 3, + 7, + 7, + 6, + 7, + 5, + 5, + 4, + 5, + 6, + 4, + 6, + 7, + 5, + 6, + 8, + 8, + 8, + 8, + 175, + 9, + 9, + 189, + 197, + 213, + 214, + 216, + 220, + 220, + 224, + 226, + 9, + 227, + 229, + 229, + 233, + 235, + 198, + 229, + 236, + 237, + 227, + 229, + 238, + 226, + 219, + 240, + 226, + 24, + 63, + 33, + 34, + 37, + 42, + 56, + 57, + 2, + 2, + 26, + 24, + 33, + 34, + 34, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 243, + 55, + 62, + 9, + 24, + 34, + 33, + 34, + 37, + 42, + 60, + 57, + 24, + 62, + 34, + 34, + 33, + 68, + 42, + 55, + 9, + 2, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 60, + 26, + 24, + 62, + 34, + 34, + 42, + 56, + 57, + 2, + 2, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 24, + 2, + 2, + 63, + 34, + 33, + 34, + 37, + 42, + 60, + 24, + 24, + 62, + 34, + 63, + 34, + 37, + 56, + 2, + 34, + 34, + 37, + 56, + 55, + 24, + 24, + 33, + 33, + 33, + 37, + 42, + 56, + 57, + 24, + 24, + 24, + 34, + 34, + 63, + 68, + 42, + 56, + 57, + 9, + 71, + 62, + 33, + 34, + 63, + 42, + 56, + 57, + 26, + 34, + 33, + 33, + 37, + 56, + 55, + 31, + 26, + 62, + 33, + 34, + 37, + 42, + 60, + 31, + 9, + 24, + 34, + 34, + 63, + 42, + 60, + 57, + 26, + 62, + 34, + 34, + 34, + 42, + 45, + 245, + 62, + 34, + 34, + 34, + 42, + 42, + 52, + 57, + 2, + 34, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 57, + 9, + 26, + 31, + 34, + 34, + 34, + 24, + 42, + 55, + 24, + 10, + 62, + 34, + 33, + 34, + 63, + 42, + 56, + 55, + 24, + 24, + 24, + 24, + 34, + 34, + 68, + 42, + 56, + 57, + 2, + 2, + 62, + 33, + 33, + 34, + 37, + 42, + 56, + 62, + 246, + 254, + 2, + 275, + 279, + 288, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 290, + 139, + 169, + 139, + 169, + 139, + 169, + 140, + 169, + 169, + 140, + 141, + 140, + 140, + 169, + 169, + 139, + 139, + 140, + 140, + 139, + 140, + 139, + 142, + 142, + 2, + 2, + 2, + 2, + 2, + 2, + 3, + 2, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 6, + 7, + 5, + 5, + 5, + 5, + 6, + 291, + 2, + 5, + 5, + 3, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 7, + 4, + 5, + 5, + 5, + 6, + 6, + 5, + 4, + 4, + 5, + 5, + 5, + 5, + 3, + 5, + 6, + 6, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 3, + 6, + 7, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 2, + 6, + 6, + 6, + 6, + 6, + 7, + 5, + 4, + 4, + 6, + 6, + 5, + 5, + 6, + 5, + 7, + 6, + 6, + 7, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 5, + 6, + 6, + 5, + 6, + 7, + 5, + 3, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 5, + 8, + 8, + 171, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 169, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 140, + 169, + 140, + 140, + 142, + 142, + 142, + 2, + 3, + 3, + 3, + 3, + 3, + 5, + 6, + 6, + 6, + 7, + 5, + 3, + 6, + 7, + 6, + 5, + 5, + 5, + 7, + 5, + 4, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 7, + 7, + 5, + 4, + 6, + 6, + 6, + 5, + 6, + 5, + 7, + 170, + 7, + 6, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 3, + 6, + 5, + 6, + 5, + 5, + 6, + 2, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 6, + 3, + 5, + 5, + 6, + 5, + 7, + 5, + 6, + 5, + 5, + 5, + 4, + 4, + 6, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 5, + 7, + 6, + 5, + 7, + 5, + 6, + 5, + 5, + 5, + 4, + 5, + 5, + 6, + 4, + 6, + 5, + 4, + 6, + 5, + 6, + 5, + 5, + 7, + 6, + 5, + 7, + 6, + 7, + 5, + 5, + 7, + 5, + 6, + 170, + 6, + 7, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 140, + 139, + 140, + 140, + 169, + 139, + 140, + 169, + 139, + 139, + 169, + 139, + 140, + 139, + 139, + 140, + 169, + 142, + 142, + 142, + 3, + 2, + 3, + 7, + 5, + 5, + 6, + 7, + 6, + 7, + 7, + 5, + 6, + 6, + 7, + 6, + 5, + 4, + 6, + 6, + 5, + 6, + 5, + 5, + 7, + 7, + 6, + 5, + 5, + 5, + 7, + 6, + 7, + 6, + 6, + 6, + 6, + 7, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 2, + 6, + 5, + 7, + 5, + 5, + 5, + 7, + 3, + 7, + 6, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 6, + 6, + 5, + 7, + 5, + 6, + 3, + 6, + 2, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 4, + 6, + 6, + 5, + 7, + 5, + 6, + 4, + 3, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 3, + 6, + 2, + 7, + 6, + 6, + 5, + 3, + 3, + 5, + 7, + 7, + 6, + 6, + 5, + 6, + 6, + 6, + 7, + 5, + 7, + 6, + 5, + 5, + 5, + 5, + 4, + 5, + 6, + 3, + 7, + 5, + 7, + 5, + 7, + 6, + 5, + 6, + 8, + 171, + 8, + 9, + 9, + 293, + 295, + 301, + 236, + 303, + 306, + 307, + 308, + 150, + 309, + 162, + 9, + 160, + 162, + 33, + 63, + 34, + 36, + 42, + 57, + 71, + 33, + 63, + 34, + 37, + 310, + 57, + 26, + 62, + 34, + 34, + 313, + 24, + 33, + 34, + 42, + 56, + 24, + 22, + 24, + 34, + 34, + 42, + 60, + 9, + 33, + 26, + 33, + 34, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 24, + 62, + 34, + 34, + 34, + 42, + 57, + 9, + 33, + 34, + 63, + 42, + 56, + 24, + 24, + 33, + 34, + 42, + 56, + 55, + 26, + 31, + 34, + 34, + 42, + 62, + 24, + 62, + 63, + 34, + 34, + 37, + 56, + 24, + 24, + 62, + 34, + 34, + 36, + 56, + 55, + 9, + 34, + 33, + 34, + 42, + 57, + 62, + 26, + 62, + 31, + 34, + 34, + 42, + 55, + 62, + 2, + 316, + 323, + 326, + 81, + 80, + 82, + 332, + 107, + 9, + 162, + 182, + 229, + 306, + 9, + 9, + 9, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 142, + 3, + 2, + 5, + 6, + 6, + 6, + 5, + 5, + 7, + 6, + 5, + 5, + 5, + 6, + 7, + 5, + 5, + 7, + 6, + 4, + 6, + 7, + 5, + 5, + 5, + 6, + 7, + 7, + 7, + 6, + 5, + 5, + 7, + 6, + 5, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 5, + 6, + 6, + 5, + 4, + 7, + 6, + 5, + 7, + 7, + 6, + 6, + 5, + 5, + 5, + 5, + 2, + 6, + 6, + 6, + 3, + 5, + 3, + 6, + 5, + 5, + 4, + 6, + 170, + 6, + 5, + 5, + 5, + 7, + 4, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 2, + 7, + 6, + 5, + 7, + 5, + 7, + 5, + 3, + 5, + 5, + 6, + 61, + 61, + 56, + 62, + 135, + 135, + 61, + 61, + 5, + 7, + 62, + 9, + 135, + 135, + 135, + 135, + 139, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 2, + 6, + 4, + 3, + 6, + 5, + 5, + 6, + 6, + 4, + 6, + 5, + 5, + 3, + 7, + 5, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 7, + 6, + 4, + 6, + 5, + 6, + 5, + 6, + 6, + 7, + 3, + 7, + 6, + 6, + 5, + 6, + 4, + 3, + 5, + 5, + 6, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 141, + 169, + 139, + 139, + 140, + 3, + 3, + 6, + 5, + 6, + 5, + 6, + 6, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 138, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 3, + 3, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 7, + 2, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 4, + 3, + 5, + 6, + 6, + 7, + 5, + 6, + 6, + 5, + 5, + 4, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 4, + 3, + 5, + 5, + 5, + 9, + 62, + 24, + 26, + 33, + 34, + 34, + 34, + 42, + 56, + 57, + 61, + 61, + 56, + 62, + 34, + 56, + 57, + 62, + 34, + 34, + 34, + 56, + 55, + 23, + 34, + 37, + 42, + 55, + 62, + 62, + 33, + 68, + 68, + 37, + 56, + 57, + 26, + 34, + 34, + 34, + 42, + 245, + 62, + 24, + 34, + 34, + 37, + 333, + 56, + 62, + 26, + 62, + 34, + 34, + 24, + 42, + 55, + 62, + 34, + 34, + 33, + 42, + 56, + 55, + 24, + 2, + 336, + 343, + 345, + 345, + 346, + 26, + 62, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 350, + 351, + 353, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 140, + 139, + 139, + 169, + 169, + 140, + 140, + 140, + 139, + 169, + 169, + 169, + 140, + 139, + 169, + 140, + 139, + 140, + 140, + 139, + 140, + 139, + 139, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 5, + 2, + 5, + 5, + 5, + 4, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 6, + 7, + 5, + 7, + 5, + 5, + 6, + 7, + 7, + 4, + 5, + 5, + 7, + 4, + 5, + 6, + 3, + 5, + 5, + 6, + 6, + 3, + 6, + 5, + 6, + 6, + 6, + 4, + 5, + 6, + 5, + 5, + 4, + 6, + 5, + 5, + 4, + 5, + 7, + 6, + 5, + 5, + 6, + 5, + 3, + 5, + 6, + 7, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 4, + 7, + 6, + 4, + 5, + 5, + 6, + 3, + 4, + 7, + 7, + 5, + 6, + 2, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 6, + 6, + 4, + 6, + 6, + 6, + 5, + 6, + 6, + 7, + 5, + 5, + 5, + 6, + 6, + 7, + 5, + 6, + 7, + 6, + 5, + 5, + 6, + 7, + 5, + 5, + 6, + 7, + 5, + 5, + 5, + 5, + 6, + 6, + 7, + 4, + 7, + 5, + 5, + 354, + 8, + 8, + 8, + 9, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 169, + 140, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 140, + 139, + 169, + 140, + 139, + 140, + 140, + 139, + 142, + 142, + 142, + 2, + 3, + 3, + 3, + 3, + 6, + 4, + 6, + 6, + 6, + 6, + 4, + 5, + 7, + 3, + 5, + 7, + 5, + 5, + 6, + 5, + 7, + 6, + 6, + 6, + 7, + 6, + 6, + 5, + 6, + 4, + 6, + 5, + 2, + 2, + 6, + 5, + 6, + 5, + 3, + 5, + 5, + 7, + 6, + 6, + 3, + 6, + 4, + 6, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 4, + 7, + 6, + 7, + 6, + 5, + 6, + 6, + 5, + 7, + 7, + 5, + 6, + 5, + 5, + 6, + 4, + 7, + 2, + 7, + 5, + 2, + 5, + 3, + 6, + 6, + 5, + 4, + 5, + 6, + 5, + 5, + 5, + 5, + 7, + 4, + 5, + 5, + 6, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 4, + 6, + 6, + 6, + 5, + 7, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 7, + 6, + 6, + 6, + 6, + 4, + 4, + 5, + 5, + 5, + 6, + 6, + 4, + 8, + 8, + 8, + 355, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 169, + 169, + 139, + 140, + 140, + 139, + 169, + 140, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 139, + 140, + 140, + 140, + 139, + 139, + 140, + 169, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 142, + 142, + 142, + 3, + 2, + 3, + 2, + 3, + 5, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 6, + 7, + 5, + 5, + 6, + 5, + 6, + 7, + 4, + 6, + 4, + 7, + 6, + 6, + 5, + 6, + 5, + 5, + 7, + 4, + 5, + 5, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 7, + 2, + 6, + 6, + 6, + 5, + 7, + 7, + 4, + 6, + 5, + 5, + 6, + 7, + 7, + 5, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 3, + 5, + 5, + 5, + 6, + 5, + 4, + 7, + 5, + 4, + 5, + 6, + 5, + 6, + 5, + 7, + 6, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 3, + 5, + 6, + 6, + 7, + 5, + 2, + 6, + 6, + 5, + 5, + 8, + 8, + 354, + 8, + 2, + 9, + 9, + 2, + 235, + 227, + 213, + 180, + 356, + 226, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 139, + 139, + 140, + 140, + 139, + 169, + 139, + 139, + 139, + 139, + 140, + 169, + 139, + 140, + 140, + 140, + 169, + 139, + 140, + 139, + 139, + 140, + 142, + 142, + 142, + 3, + 3, + 3, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 7, + 7, + 6, + 5, + 5, + 6, + 7, + 6, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 6, + 7, + 7, + 5, + 6, + 5, + 4, + 5, + 7, + 6, + 5, + 7, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 7, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 3, + 5, + 5, + 6, + 4, + 5, + 6, + 7, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 7, + 5, + 5, + 5, + 6, + 4, + 5, + 6, + 6, + 4, + 5, + 5, + 7, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 7, + 5, + 4, + 6, + 7, + 5, + 170, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 7, + 5, + 5, + 2, + 5, + 4, + 5, + 6, + 354, + 8, + 171, + 171, + 355, + 9, + 9, + 9, + 34, + 34, + 34, + 63, + 37, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 55, + 62, + 24, + 62, + 34, + 33, + 63, + 42, + 56, + 55, + 9, + 31, + 24, + 34, + 34, + 68, + 42, + 55, + 26, + 62, + 34, + 34, + 34, + 42, + 39, + 55, + 26, + 31, + 34, + 34, + 34, + 42, + 42, + 55, + 62, + 357, + 24, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 9, + 24, + 34, + 34, + 34, + 42, + 56, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 2, + 71, + 24, + 34, + 34, + 34, + 68, + 56, + 55, + 24, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 24, + 33, + 33, + 34, + 37, + 56, + 55, + 24, + 62, + 34, + 34, + 33, + 36, + 42, + 245, + 62, + 26, + 62, + 34, + 34, + 34, + 42, + 52, + 62, + 62, + 34, + 63, + 34, + 63, + 37, + 42, + 60, + 62, + 33, + 34, + 34, + 37, + 42, + 55, + 26, + 34, + 34, + 33, + 34, + 42, + 56, + 62, + 26, + 24, + 34, + 34, + 37, + 42, + 363, + 24, + 24, + 26, + 62, + 34, + 34, + 63, + 37, + 42, + 56, + 55, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 113, + 109, + 367, + 9, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 140, + 139, + 140, + 140, + 140, + 169, + 140, + 139, + 169, + 140, + 169, + 169, + 139, + 139, + 169, + 140, + 139, + 140, + 139, + 140, + 139, + 142, + 142, + 2, + 2, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 7, + 7, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 7, + 6, + 5, + 5, + 6, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 7, + 5, + 6, + 7, + 5, + 5, + 7, + 6, + 5, + 4, + 5, + 7, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 6, + 2, + 6, + 5, + 6, + 6, + 5, + 7, + 7, + 4, + 7, + 6, + 5, + 4, + 6, + 5, + 6, + 6, + 6, + 5, + 3, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 6, + 5, + 7, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 7, + 4, + 5, + 5, + 6, + 4, + 61, + 140, + 3, + 3, + 4, + 5, + 61, + 7, + 61, + 3, + 61, + 61, + 61, + 5, + 6, + 61, + 61, + 5, + 6, + 5, + 7, + 4, + 7, + 61, + 61, + 61, + 4, + 5, + 61, + 5, + 6, + 5, + 6, + 5, + 5, + 7, + 7, + 5, + 61, + 4, + 61, + 5, + 7, + 6, + 5, + 4, + 5, + 5, + 7, + 7, + 5, + 7, + 61, + 6, + 6, + 5, + 5, + 5, + 4, + 5, + 5, + 3, + 5, + 5, + 4, + 6, + 5, + 6, + 7, + 6, + 5, + 5, + 5, + 5, + 61, + 8, + 354, + 8, + 8, + 8, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 9, + 33, + 61, + 61, + 33, + 34, + 33, + 61, + 42, + 42, + 56, + 363, + 33, + 61, + 61, + 33, + 61, + 42, + 42, + 56, + 57, + 24, + 24, + 33, + 33, + 61, + 34, + 34, + 34, + 33, + 34, + 33, + 34, + 63, + 68, + 37, + 37, + 61, + 57, + 9, + 26, + 24, + 68, + 24, + 34, + 61, + 61, + 37, + 42, + 56, + 34, + 34, + 33, + 61, + 2, + 37, + 34, + 52, + 34, + 34, + 63, + 34, + 33, + 61, + 24, + 34, + 61, + 37, + 42, + 34, + 63, + 33, + 37, + 37, + 42, + 42, + 61, + 42, + 56, + 57, + 37, + 61, + 42, + 42, + 42, + 24, + 61, + 33, + 61, + 33, + 34, + 33, + 61, + 61, + 34, + 33, + 34, + 57, + 61, + 63, + 61, + 61, + 61, + 61, + 56, + 57, + 2, + 71, + 62, + 34, + 34, + 63, + 33, + 37, + 42, + 40, + 363, + 24, + 61, + 22, + 71, + 31, + 24, + 369, + 33, + 61, + 34, + 61, + 63, + 61, + 61, + 37, + 42, + 61, + 42, + 61, + 363, + 57, + 9, + 26, + 24, + 34, + 63, + 33, + 24, + 61, + 42, + 61, + 363, + 24, + 9, + 22, + 26, + 31, + 34, + 33, + 61, + 61, + 34, + 37, + 42, + 61, + 363, + 55, + 62, + 2, + 376, + 377, + 22, + 24, + 31, + 378, + 389, + 2, + 147, + 160, + 162, + 162, + 165, + 61, + 61, + 62, + 33, + 34, + 34, + 33, + 34, + 62, + 26, + 63, + 61, + 33, + 33, + 61, + 34, + 37, + 42, + 56, + 363, + 24, + 33, + 63, + 34, + 34, + 37, + 333, + 56, + 55, + 61, + 61, + 33, + 34, + 63, + 34, + 37, + 42, + 61, + 56, + 363, + 61, + 34, + 61, + 61, + 52, + 26, + 37, + 57, + 24, + 61, + 61, + 61, + 333, + 57, + 31, + 61, + 61, + 63, + 34, + 61, + 34, + 33, + 34, + 42, + 56, + 61, + 24, + 9, + 2, + 2, + 24, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 63, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 61, + 42, + 61, + 52, + 57, + 65, + 33, + 34, + 34, + 37, + 42, + 52, + 55, + 24, + 24, + 61, + 61, + 34, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 63, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 52, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 363, + 245, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 22, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 37, + 42, + 55, + 24, + 2, + 34, + 63, + 34, + 37, + 56, + 55, + 9, + 24, + 33, + 63, + 34, + 37, + 42, + 56, + 34, + 34, + 34, + 34, + 36, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 63, + 390, + 42, + 56, + 62, + 62, + 34, + 34, + 37, + 34, + 34, + 34, + 34, + 42, + 42, + 57, + 392, + 9, + 9, + 393, + 195, + 229, + 235, + 9, + 9, + 26, + 63, + 33, + 24, + 34, + 34, + 37, + 42, + 52, + 57, + 24, + 2, + 24, + 34, + 34, + 34, + 37, + 52, + 24, + 2, + 62, + 34, + 34, + 33, + 61, + 42, + 42, + 42, + 22, + 34, + 33, + 34, + 34, + 42, + 56, + 57, + 62, + 33, + 34, + 34, + 37, + 60, + 62, + 24, + 24, + 34, + 34, + 24, + 24, + 31, + 34, + 34, + 34, + 42, + 56, + 245, + 57, + 23, + 2, + 24, + 62, + 34, + 34, + 33, + 42, + 56, + 55, + 62, + 24, + 62, + 33, + 63, + 34, + 24, + 42, + 56, + 57, + 26, + 24, + 62, + 34, + 34, + 24, + 37, + 42, + 56, + 55, + 327, + 62, + 34, + 34, + 34, + 42, + 56, + 62, + 34, + 34, + 42, + 55, + 62, + 396, + 394, + 233, + 9, + 182, + 229, + 232, + 237, + 9, + 9, + 24, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 63, + 42, + 56, + 55, + 24, + 24, + 62, + 34, + 63, + 34, + 42, + 56, + 57, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 22, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 2, + 62, + 34, + 33, + 34, + 36, + 42, + 56, + 363, + 57, + 24, + 24, + 33, + 34, + 34, + 68, + 42, + 56, + 24, + 24, + 26, + 34, + 33, + 33, + 34, + 42, + 56, + 56, + 57, + 24, + 9, + 33, + 34, + 34, + 33, + 37, + 42, + 52, + 57, + 62, + 24, + 24, + 34, + 33, + 37, + 42, + 42, + 56, + 363, + 24, + 65, + 62, + 31, + 34, + 34, + 34, + 397, + 42, + 56, + 57, + 21, + 24, + 62, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 24, + 62, + 2, + 24, + 33, + 63, + 34, + 34, + 42, + 56, + 56, + 57, + 313, + 24, + 62, + 34, + 34, + 34, + 33, + 42, + 56, + 52, + 57, + 31, + 26, + 62, + 34, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 55, + 10, + 9, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 62, + 26, + 34, + 63, + 34, + 37, + 42, + 52, + 57, + 24, + 34, + 24, + 33, + 37, + 42, + 56, + 62, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 19, + 62, + 33, + 34, + 33, + 34, + 42, + 42, + 52, + 62, + 9, + 62, + 34, + 34, + 34, + 37, + 44, + 52, + 23, + 2, + 62, + 34, + 33, + 34, + 37, + 42, + 44, + 363, + 57, + 24, + 26, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 62, + 9, + 24, + 34, + 34, + 33, + 68, + 42, + 56, + 55, + 24, + 62, + 26, + 34, + 34, + 34, + 24, + 42, + 56, + 55, + 62, + 22, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 60, + 62, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 22, + 33, + 34, + 34, + 36, + 42, + 52, + 62, + 62, + 26, + 24, + 26, + 24, + 34, + 33, + 34, + 68, + 42, + 56, + 245, + 37, + 42, + 55, + 62, + 398, + 403, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 405, + 141, + 140, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 141, + 141, + 169, + 139, + 139, + 139, + 172, + 172, + 172, + 172, + 139, + 140, + 172, + 139, + 139, + 172, + 172, + 172, + 172, + 172, + 140, + 172, + 172, + 172, + 139, + 174, + 172, + 172, + 139, + 172, + 172, + 172, + 173, + 172, + 173, + 172, + 140, + 172, + 142, + 142, + 142, + 142, + 3, + 3, + 5, + 6, + 5, + 6, + 7, + 5, + 5, + 4, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 6, + 6, + 4, + 6, + 6, + 3, + 5, + 4, + 5, + 2, + 5, + 4, + 6, + 4, + 5, + 6, + 7, + 5, + 6, + 5, + 6, + 6, + 6, + 4, + 6, + 6, + 6, + 5, + 6, + 7, + 5, + 5, + 6, + 170, + 5, + 7, + 6, + 4, + 5, + 6, + 6, + 6, + 7, + 5, + 5, + 7, + 6, + 6, + 6, + 6, + 6, + 4, + 3, + 7, + 6, + 5, + 6, + 5, + 7, + 6, + 7, + 5, + 7, + 5, + 7, + 5, + 8, + 2, + 33, + 24, + 34, + 61, + 42, + 61, + 3, + 6, + 5, + 4, + 5, + 6, + 6, + 6, + 6, + 6, + 5, + 6, + 7, + 24, + 34, + 24, + 34, + 63, + 34, + 37, + 56, + 57, + 62, + 63, + 33, + 34, + 34, + 42, + 56, + 9, + 62, + 34, + 34, + 33, + 33, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 68, + 42, + 407, + 26, + 55, + 24, + 22, + 62, + 40, + 55, + 57, + 24, + 9, + 31, + 62, + 34, + 34, + 33, + 34, + 33, + 33, + 37, + 42, + 56, + 55, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 42, + 56, + 2, + 135, + 135, + 135, + 135, + 135, + 140, + 139, + 140, + 140, + 3, + 5, + 6, + 6, + 7, + 6, + 5, + 6, + 4, + 5, + 5, + 7, + 7, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 170, + 4, + 6, + 5, + 6, + 7, + 6, + 6, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 3, + 7, + 3, + 5, + 4, + 5, + 6, + 6, + 5, + 7, + 7, + 5, + 6, + 6, + 5, + 7, + 5, + 7, + 2, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 7, + 6, + 6, + 6, + 6, + 6, + 5, + 4, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 8, + 8, + 8, + 171, + 2, + 9, + 9, + 2, + 408, + 412, + 162, + 162, + 413, + 26, + 34, + 33, + 34, + 42, + 56, + 57, + 24, + 26, + 55, + 26, + 24, + 34, + 34, + 37, + 42, + 33, + 68, + 42, + 56, + 55, + 415, + 24, + 62, + 34, + 34, + 33, + 68, + 42, + 56, + 24, + 26, + 24, + 42, + 55, + 9, + 63, + 33, + 34, + 61, + 61, + 61, + 61, + 9, + 56, + 57, + 24, + 26, + 390, + 42, + 52, + 9, + 34, + 34, + 34, + 42, + 62, + 24, + 34, + 63, + 56, + 2, + 26, + 34, + 33, + 68, + 52, + 422, + 425, + 425, + 425, + 425, + 426, + 427, + 427, + 446, + 449, + 455, + 351, + 366, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 2, + 22, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 57, + 62, + 26, + 467, + 140, + 7, + 5, + 6, + 6, + 7, + 4, + 4, + 7, + 7, + 5, + 6, + 7, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 6, + 6, + 7, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 7, + 3, + 3, + 5, + 6, + 5, + 6, + 5, + 5, + 4, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 8, + 8, + 354, + 354, + 9, + 2, + 9, + 167, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 124, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 140, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 141, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 169, + 140, + 169, + 169, + 140, + 139, + 142, + 142, + 142, + 142, + 2, + 3, + 3, + 7, + 7, + 6, + 5, + 5, + 5, + 5, + 7, + 7, + 5, + 5, + 170, + 5, + 7, + 6, + 6, + 6, + 5, + 5, + 6, + 4, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 7, + 7, + 4, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 7, + 4, + 5, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 7, + 6, + 5, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 4, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 7, + 5, + 6, + 5, + 5, + 5, + 7, + 6, + 6, + 7, + 5, + 5, + 7, + 5, + 5, + 6, + 5, + 6, + 3, + 6, + 4, + 3, + 3, + 7, + 5, + 5, + 4, + 8, + 8, + 8, + 8, + 8, + 9, + 469, + 470, + 167, + 471, + 472, + 229, + 147, + 308, + 217, + 65, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 62, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 62, + 62, + 24, + 34, + 33, + 34, + 42, + 56, + 57, + 33, + 34, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 42, + 42, + 56, + 57, + 62, + 24, + 26, + 24, + 34, + 63, + 34, + 34, + 40, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 42, + 55, + 24, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 33, + 33, + 34, + 63, + 42, + 56, + 52, + 24, + 22, + 62, + 24, + 24, + 62, + 34, + 34, + 33, + 333, + 61, + 245, + 24, + 62, + 34, + 33, + 34, + 42, + 56, + 363, + 62, + 24, + 34, + 33, + 33, + 42, + 56, + 57, + 62, + 26, + 33, + 63, + 34, + 37, + 42, + 52, + 62, + 24, + 113, + 367, + 480, + 485, + 160, + 162, + 393, + 205, + 233, + 237, + 26, + 62, + 34, + 34, + 34, + 42, + 55, + 22, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 34, + 2, + 34, + 34, + 68, + 56, + 55, + 24, + 26, + 24, + 62, + 63, + 34, + 37, + 42, + 55, + 24, + 34, + 34, + 37, + 42, + 56, + 24, + 62, + 62, + 24, + 63, + 34, + 34, + 71, + 34, + 57, + 26, + 62, + 56, + 34, + 24, + 63, + 37, + 42, + 24, + 33, + 37, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 34, + 34, + 34, + 34, + 56, + 57, + 34, + 34, + 56, + 24, + 2, + 24, + 26, + 62, + 63, + 34, + 37, + 42, + 60, + 62, + 24, + 33, + 34, + 34, + 68, + 42, + 62, + 34, + 34, + 333, + 24, + 24, + 57, + 2, + 34, + 34, + 37, + 56, + 57, + 24, + 34, + 56, + 57, + 33, + 34, + 42, + 56, + 57, + 24, + 34, + 34, + 34, + 333, + 56, + 57, + 9, + 62, + 34, + 63, + 42, + 56, + 24, + 9, + 33, + 34, + 42, + 57, + 34, + 34, + 56, + 37, + 56, + 407, + 62, + 56, + 62, + 62, + 62, + 62, + 56, + 62, + 34, + 9, + 2, + 42, + 57, + 9, + 34, + 42, + 56, + 24, + 24, + 34, + 34, + 37, + 56, + 34, + 63, + 34, + 42, + 62, + 34, + 33, + 37, + 56, + 62, + 34, + 34, + 42, + 55, + 313, + 111, + 9, + 34, + 56, + 57, + 37, + 56, + 34, + 42, + 55, + 62, + 24, + 34, + 34, + 34, + 363, + 34, + 33, + 33, + 55, + 62, + 71, + 24, + 34, + 34, + 37, + 42, + 34, + 34, + 42, + 63, + 2, + 34, + 33, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 55, + 24, + 9, + 24, + 34, + 34, + 42, + 60, + 26, + 24, + 34, + 34, + 56, + 57, + 9, + 62, + 34, + 34, + 56, + 57, + 24, + 56, + 62, + 2, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 140, + 139, + 139, + 169, + 169, + 169, + 140, + 169, + 169, + 139, + 140, + 139, + 140, + 140, + 169, + 139, + 141, + 139, + 140, + 139, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 7, + 5, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 3, + 6, + 5, + 6, + 4, + 6, + 6, + 6, + 5, + 6, + 5, + 7, + 5, + 5, + 5, + 5, + 4, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 7, + 4, + 5, + 6, + 7, + 5, + 7, + 6, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 486, + 5, + 6, + 6, + 6, + 7, + 5, + 4, + 5, + 5, + 6, + 6, + 170, + 5, + 6, + 5, + 6, + 6, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 6, + 6, + 6, + 3, + 5, + 7, + 5, + 7, + 7, + 5, + 6, + 6, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 6, + 5, + 5, + 2, + 6, + 7, + 7, + 5, + 6, + 5, + 5, + 354, + 8, + 8, + 2, + 9, + 24, + 2, + 26, + 62, + 24, + 26, + 62, + 34, + 34, + 34, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 139, + 3, + 5, + 7, + 5, + 4, + 6, + 5, + 5, + 7, + 5, + 5, + 7, + 4, + 6, + 6, + 5, + 7, + 5, + 7, + 5, + 5, + 7, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 3, + 7, + 6, + 6, + 7, + 6, + 5, + 3, + 6, + 5, + 3, + 6, + 7, + 5, + 170, + 5, + 4, + 6, + 7, + 6, + 6, + 5, + 5, + 4, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 3, + 7, + 6, + 7, + 4, + 6, + 5, + 6, + 3, + 5, + 6, + 6, + 5, + 4, + 5, + 6, + 7, + 5, + 7, + 4, + 6, + 6, + 6, + 7, + 5, + 5, + 7, + 7, + 2, + 5, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 5, + 5, + 3, + 6, + 8, + 171, + 171, + 8, + 2, + 9, + 488, + 147, + 489, + 160, + 162, + 162, + 490, + 2, + 9, + 9, + 24, + 63, + 33, + 34, + 34, + 42, + 56, + 55, + 62, + 24, + 34, + 33, + 33, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 55, + 26, + 9, + 33, + 57, + 62, + 22, + 24, + 34, + 34, + 34, + 42, + 62, + 34, + 37, + 56, + 34, + 2, + 24, + 26, + 34, + 34, + 56, + 62, + 34, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 125, + 491, + 199, + 226, + 9, + 34, + 24, + 62, + 62, + 34, + 33, + 42, + 56, + 26, + 34, + 34, + 42, + 55, + 24, + 26, + 63, + 34, + 33, + 37, + 42, + 55, + 22, + 34, + 34, + 42, + 56, + 24, + 33, + 34, + 34, + 38, + 42, + 52, + 57, + 34, + 34, + 34, + 42, + 60, + 31, + 22, + 34, + 63, + 34, + 42, + 57, + 26, + 62, + 63, + 33, + 34, + 24, + 42, + 55, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 26, + 24, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 62, + 2, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 62, + 33, + 56, + 62, + 26, + 24, + 24, + 34, + 34, + 34, + 42, + 52, + 9, + 233, + 499, + 113, + 366, + 9, + 26, + 24, + 26, + 24, + 62, + 34, + 34, + 34, + 68, + 42, + 60, + 62, + 62, + 34, + 63, + 63, + 42, + 56, + 55, + 24, + 65, + 62, + 34, + 34, + 34, + 68, + 42, + 57, + 9, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 62, + 26, + 63, + 34, + 42, + 56, + 55, + 327, + 24, + 63, + 34, + 37, + 42, + 245, + 24, + 33, + 34, + 34, + 68, + 56, + 52, + 24, + 62, + 71, + 34, + 34, + 34, + 68, + 42, + 55, + 9, + 34, + 62, + 33, + 63, + 34, + 24, + 56, + 55, + 9, + 24, + 34, + 34, + 42, + 56, + 55, + 62, + 24, + 34, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 62, + 62, + 2, + 409, + 159, + 162, + 157, + 147, + 159, + 162, + 24, + 34, + 2, + 34, + 34, + 55, + 2, + 56, + 9, + 62, + 34, + 42, + 24, + 68, + 34, + 9, + 34, + 42, + 33, + 24, + 34, + 55, + 34, + 34, + 2, + 33, + 34, + 61, + 9, + 2, + 2, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 169, + 172, + 140, + 139, + 2, + 6, + 5, + 6, + 6, + 6, + 6, + 6, + 4, + 5, + 6, + 4, + 6, + 5, + 6, + 4, + 6, + 5, + 6, + 6, + 5, + 6, + 7, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 2, + 2, + 7, + 5, + 6, + 6, + 4, + 6, + 7, + 4, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 333, + 56, + 57, + 2, + 71, + 34, + 34, + 34, + 24, + 34, + 34, + 33, + 42, + 55, + 42, + 55, + 34, + 34, + 62, + 26, + 33, + 34, + 68, + 42, + 55, + 24, + 24, + 62, + 34, + 37, + 42, + 56, + 55, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 2, + 62, + 63, + 34, + 37, + 42, + 56, + 62, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 9, + 9, + 9, + 227, + 147, + 306, + 237, + 500, + 24, + 62, + 34, + 34, + 34, + 33, + 42, + 56, + 55, + 26, + 62, + 34, + 34, + 24, + 45, + 55, + 62, + 22, + 34, + 34, + 33, + 42, + 56, + 57, + 24, + 9, + 24, + 34, + 34, + 34, + 33, + 42, + 56, + 57, + 62, + 24, + 63, + 34, + 34, + 42, + 56, + 62, + 24, + 34, + 34, + 33, + 42, + 56, + 24, + 33, + 34, + 24, + 501, + 24, + 34, + 33, + 42, + 42, + 42, + 57, + 9, + 24, + 34, + 34, + 34, + 37, + 24, + 9, + 62, + 34, + 34, + 42, + 56, + 55, + 62, + 34, + 34, + 37, + 56, + 55, + 24, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 34, + 34, + 24, + 34, + 52, + 62, + 9, + 63, + 22, + 24, + 34, + 37, + 24, + 26, + 24, + 62, + 62, + 33, + 36, + 57, + 34, + 63, + 37, + 62, + 26, + 31, + 34, + 34, + 33, + 56, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 57, + 22, + 24, + 34, + 33, + 33, + 42, + 55, + 62, + 26, + 62, + 34, + 34, + 42, + 56, + 57, + 2, + 62, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 9, + 31, + 34, + 34, + 34, + 42, + 245, + 24, + 24, + 24, + 62, + 34, + 34, + 42, + 56, + 55, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 71, + 24, + 34, + 33, + 34, + 24, + 42, + 60, + 24, + 71, + 33, + 34, + 33, + 34, + 37, + 42, + 56, + 62, + 24, + 71, + 62, + 9, + 62, + 2, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 26, + 34, + 34, + 34, + 68, + 42, + 55, + 24, + 34, + 34, + 34, + 36, + 56, + 57, + 24, + 34, + 33, + 34, + 42, + 52, + 24, + 62, + 22, + 62, + 2, + 34, + 63, + 68, + 42, + 363, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 24, + 62, + 34, + 34, + 33, + 42, + 56, + 55, + 26, + 24, + 62, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 55, + 24, + 9, + 62, + 62, + 34, + 33, + 34, + 37, + 42, + 56, + 24, + 167, + 9, + 26, + 62, + 26, + 33, + 42, + 56, + 57, + 24, + 62, + 62, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 9, + 24, + 33, + 34, + 34, + 34, + 42, + 56, + 57, + 26, + 34, + 34, + 37, + 56, + 57, + 62, + 24, + 33, + 34, + 34, + 34, + 502, + 55, + 62, + 24, + 33, + 34, + 42, + 56, + 57, + 24, + 34, + 34, + 37, + 56, + 52, + 24, + 26, + 33, + 34, + 34, + 37, + 42, + 56, + 62, + 24, + 24, + 34, + 34, + 33, + 37, + 42, + 56, + 55, + 24, + 9, + 24, + 24, + 26, + 24, + 34, + 34, + 37, + 42, + 363, + 24, + 24, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 26, + 24, + 34, + 33, + 34, + 42, + 56, + 55, + 62, + 24, + 62, + 34, + 34, + 63, + 42, + 56, + 55, + 24, + 2, + 9, + 34, + 63, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 34, + 34, + 34, + 37, + 42, + 52, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 62, + 34, + 34, + 34, + 37, + 56, + 245, + 62, + 24, + 62, + 34, + 34, + 34, + 333, + 56, + 57, + 26, + 24, + 34, + 34, + 63, + 42, + 45, + 363, + 24, + 26, + 33, + 33, + 33, + 34, + 37, + 42, + 56, + 24, + 24, + 62, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 22, + 24, + 33, + 42, + 56, + 57, + 24, + 71, + 33, + 34, + 34, + 33, + 42, + 60, + 24, + 62, + 33, + 68, + 56, + 57, + 2, + 34, + 34, + 34, + 37, + 333, + 363, + 24, + 24, + 24, + 34, + 33, + 34, + 37, + 42, + 57, + 34, + 34, + 24, + 56, + 363, + 24, + 62, + 24, + 34, + 37, + 52, + 62, + 63, + 33, + 42, + 55, + 24, + 33, + 33, + 42, + 55, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 2, + 2, + 26, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 2, + 24, + 34, + 34, + 33, + 37, + 42, + 55, + 24, + 26, + 34, + 34, + 24, + 42, + 56, + 24, + 24, + 71, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 23, + 26, + 62, + 26, + 62, + 34, + 34, + 34, + 68, + 42, + 55, + 9, + 62, + 63, + 63, + 34, + 34, + 37, + 42, + 55, + 24, + 29, + 24, + 34, + 34, + 34, + 68, + 42, + 42, + 55, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 363, + 24, + 62, + 34, + 34, + 33, + 34, + 42, + 55, + 62, + 23, + 24, + 34, + 33, + 34, + 42, + 56, + 60, + 62, + 9, + 34, + 34, + 63, + 33, + 42, + 42, + 363, + 24, + 9, + 62, + 62, + 61, + 33, + 34, + 34, + 42, + 56, + 57, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 24, + 62, + 34, + 33, + 33, + 37, + 42, + 55, + 62, + 34, + 63, + 34, + 37, + 42, + 56, + 9, + 2, + 9, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 24, + 62, + 33, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 62, + 63, + 2, + 34, + 42, + 56, + 55, + 24, + 26, + 62, + 24, + 34, + 34, + 42, + 56, + 55, + 57, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 357, + 62, + 24, + 34, + 33, + 33, + 42, + 56, + 55, + 24, + 62, + 34, + 34, + 63, + 36, + 333, + 56, + 57, + 65, + 24, + 24, + 24, + 24, + 26, + 62, + 34, + 34, + 33, + 37, + 333, + 56, + 55, + 24, + 22, + 24, + 33, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 34, + 34, + 34, + 34, + 42, + 42, + 60, + 24, + 62, + 24, + 24, + 26, + 34, + 34, + 24, + 42, + 56, + 55, + 24, + 26, + 34, + 34, + 33, + 34, + 42, + 363, + 62, + 313, + 24, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 22, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 2, + 2, + 9, + 62, + 24, + 34, + 33, + 34, + 333, + 42, + 49, + 57, + 22, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 245, + 62, + 62, + 34, + 34, + 34, + 42, + 45, + 55, + 24, + 26, + 62, + 24, + 26, + 63, + 34, + 33, + 33, + 42, + 56, + 363, + 24, + 26, + 24, + 34, + 34, + 34, + 34, + 37, + 56, + 57, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 42, + 363, + 9, + 34, + 34, + 63, + 34, + 42, + 56, + 52, + 57, + 62, + 34, + 34, + 34, + 34, + 2, + 42, + 56, + 55, + 62, + 357, + 26, + 62, + 63, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 24, + 24, + 34, + 34, + 34, + 2, + 42, + 56, + 57, + 65, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 63, + 34, + 34, + 36, + 42, + 55, + 24, + 62, + 71, + 34, + 34, + 34, + 68, + 333, + 56, + 55, + 62, + 29, + 34, + 33, + 34, + 42, + 56, + 55, + 62, + 26, + 24, + 34, + 33, + 34, + 33, + 42, + 56, + 55, + 24, + 26, + 34, + 33, + 34, + 33, + 42, + 42, + 55, + 24, + 81, + 503, + 9, + 9, + 24, + 62, + 26, + 62, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 9, + 24, + 63, + 34, + 63, + 68, + 42, + 56, + 55, + 62, + 62, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 2, + 26, + 24, + 62, + 62, + 63, + 33, + 34, + 37, + 42, + 56, + 57, + 62, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 60, + 57, + 24, + 24, + 34, + 34, + 34, + 34, + 42, + 42, + 363, + 23, + 26, + 34, + 34, + 34, + 33, + 42, + 42, + 56, + 57, + 2, + 62, + 34, + 24, + 33, + 34, + 42, + 56, + 363, + 62, + 26, + 34, + 34, + 34, + 33, + 68, + 42, + 363, + 24, + 62, + 26, + 24, + 34, + 34, + 33, + 37, + 42, + 34, + 34, + 33, + 37, + 56, + 62, + 22, + 62, + 24, + 34, + 33, + 36, + 56, + 57, + 26, + 24, + 34, + 34, + 24, + 56, + 57, + 34, + 34, + 34, + 37, + 42, + 56, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 2, + 2, + 9, + 34, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 24, + 9, + 34, + 33, + 34, + 37, + 56, + 57, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 26, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 504, + 24, + 2, + 34, + 34, + 34, + 42, + 56, + 55, + 9, + 24, + 62, + 34, + 34, + 34, + 34, + 42, + 40, + 363, + 24, + 62, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 56, + 55, + 24, + 26, + 24, + 34, + 34, + 33, + 34, + 42, + 42, + 60, + 24, + 26, + 62, + 62, + 33, + 37, + 42, + 56, + 57, + 22, + 34, + 34, + 26, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 34, + 63, + 34, + 33, + 42, + 56, + 57, + 505, + 2, + 178, + 509, + 510, + 511, + 9, + 24, + 33, + 33, + 34, + 333, + 56, + 55, + 62, + 9, + 24, + 34, + 63, + 63, + 42, + 56, + 55, + 24, + 9, + 24, + 62, + 33, + 34, + 34, + 42, + 56, + 55, + 2, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 62, + 24, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 22, + 24, + 34, + 34, + 2, + 37, + 42, + 56, + 57, + 24, + 26, + 62, + 33, + 33, + 34, + 68, + 42, + 56, + 55, + 22, + 24, + 33, + 33, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 57, + 24, + 34, + 34, + 63, + 37, + 56, + 245, + 24, + 9, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 62, + 34, + 34, + 34, + 42, + 42, + 55, + 24, + 24, + 24, + 26, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 62, + 62, + 62, + 62, + 63, + 33, + 34, + 42, + 42, + 60, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 2, + 9, + 22, + 24, + 34, + 33, + 34, + 33, + 42, + 42, + 241, + 57, + 512, + 24, + 33, + 34, + 24, + 42, + 56, + 62, + 24, + 26, + 24, + 33, + 33, + 34, + 37, + 42, + 56, + 55, + 9, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 22, + 24, + 24, + 26, + 34, + 34, + 34, + 24, + 42, + 61, + 55, + 24, + 9, + 62, + 63, + 34, + 34, + 68, + 56, + 55, + 24, + 22, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 62, + 26, + 34, + 34, + 55, + 357, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 245, + 24, + 9, + 2, + 9, + 24, + 34, + 34, + 63, + 68, + 42, + 56, + 60, + 24, + 62, + 34, + 63, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 23, + 62, + 34, + 34, + 34, + 34, + 34, + 42, + 42, + 56, + 55, + 2, + 24, + 34, + 34, + 56, + 55, + 26, + 34, + 34, + 37, + 42, + 40, + 62, + 26, + 34, + 34, + 33, + 68, + 333, + 56, + 56, + 57, + 24, + 65, + 62, + 33, + 34, + 34, + 68, + 42, + 56, + 55, + 57, + 24, + 26, + 31, + 31, + 26, + 62, + 24, + 33, + 37, + 42, + 56, + 57, + 24, + 33, + 37, + 37, + 42, + 42, + 56, + 57, + 24, + 65, + 34, + 42, + 56, + 52, + 57, + 24, + 62, + 34, + 57, + 26, + 34, + 34, + 63, + 34, + 42, + 56, + 55, + 24, + 24, + 24, + 9, + 65, + 24, + 71, + 63, + 34, + 34, + 502, + 42, + 56, + 24, + 24, + 24, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 9, + 9, + 2, + 24, + 24, + 34, + 34, + 34, + 34, + 34, + 42, + 56, + 52, + 57, + 22, + 33, + 34, + 42, + 56, + 62, + 514, + 24, + 62, + 22, + 62, + 34, + 34, + 34, + 33, + 42, + 42, + 56, + 55, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 9, + 62, + 34, + 34, + 34, + 33, + 68, + 42, + 56, + 52, + 57, + 24, + 26, + 24, + 33, + 34, + 33, + 34, + 63, + 42, + 56, + 55, + 24, + 26, + 33, + 34, + 34, + 42, + 57, + 62, + 24, + 33, + 34, + 34, + 68, + 42, + 42, + 56, + 55, + 24, + 26, + 33, + 33, + 34, + 42, + 56, + 57, + 9, + 24, + 34, + 33, + 34, + 68, + 42, + 363, + 62, + 24, + 2, + 24, + 34, + 34, + 34, + 68, + 42, + 44, + 361, + 57, + 24, + 22, + 24, + 22, + 24, + 42, + 52, + 62, + 9, + 24, + 34, + 33, + 63, + 42, + 42, + 55, + 24, + 2, + 62, + 63, + 34, + 34, + 333, + 56, + 57, + 24, + 71, + 33, + 34, + 63, + 37, + 56, + 55, + 24, + 24, + 22, + 24, + 24, + 24, + 34, + 34, + 34, + 34, + 333, + 56, + 55, + 24, + 24, + 34, + 369, + 34, + 42, + 56, + 56, + 24, + 30, + 26, + 62, + 24, + 24, + 34, + 63, + 34, + 34, + 42, + 333, + 56, + 55, + 9, + 62, + 33, + 63, + 63, + 34, + 68, + 42, + 56, + 55, + 62, + 24, + 62, + 34, + 34, + 34, + 36, + 42, + 56, + 363, + 57, + 26, + 24, + 33, + 63, + 34, + 24, + 56, + 60, + 24, + 24, + 24, + 24, + 34, + 33, + 34, + 33, + 37, + 42, + 56, + 55, + 62, + 26, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 26, + 62, + 34, + 34, + 34, + 37, + 56, + 363, + 24, + 2, + 62, + 34, + 61, + 472, + 219, + 42, + 34, + 42, + 42, + 26, + 57, + 9, + 55, + 62, + 42, + 62, + 34, + 34, + 24, + 9, + 9, + 9, + 9, + 10, + 62, + 24, + 2, + 34, + 37, + 42, + 56, + 57, + 2, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 24, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 52, + 57, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 34, + 34, + 63, + 62, + 60, + 61, + 61, + 34, + 34, + 34, + 9, + 37, + 57, + 34, + 57, + 62, + 34, + 2, + 56, + 65, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 42, + 60, + 24, + 34, + 34, + 34, + 63, + 42, + 56, + 57, + 24, + 34, + 34, + 34, + 37, + 42, + 26, + 34, + 63, + 37, + 56, + 24, + 71, + 24, + 24, + 33, + 34, + 34, + 42, + 56, + 57, + 524, + 33, + 34, + 34, + 42, + 56, + 55, + 26, + 24, + 34, + 33, + 34, + 24, + 42, + 55, + 24, + 24, + 34, + 33, + 34, + 42, + 42, + 56, + 57, + 24, + 26, + 71, + 24, + 34, + 34, + 34, + 42, + 42, + 34, + 34, + 33, + 37, + 56, + 57, + 9, + 71, + 33, + 34, + 34, + 37, + 56, + 62, + 24, + 2, + 24, + 33, + 34, + 33, + 36, + 42, + 55, + 26, + 34, + 34, + 34, + 37, + 42, + 52, + 24, + 24, + 9, + 62, + 63, + 34, + 34, + 42, + 56, + 55, + 26, + 62, + 34, + 34, + 34, + 2, + 37, + 42, + 55, + 65, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 26, + 24, + 34, + 34, + 68, + 42, + 52, + 24, + 71, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 9, + 34, + 33, + 34, + 34, + 42, + 56, + 24, + 26, + 34, + 34, + 63, + 42, + 56, + 55, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 140, + 139, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 169, + 169, + 142, + 142, + 142, + 142, + 3, + 3, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 4, + 6, + 7, + 5, + 7, + 3, + 5, + 6, + 7, + 6, + 6, + 6, + 6, + 5, + 7, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 7, + 6, + 6, + 6, + 6, + 6, + 7, + 5, + 5, + 5, + 5, + 5, + 170, + 5, + 5, + 4, + 5, + 7, + 5, + 5, + 5, + 5, + 7, + 6, + 6, + 7, + 5, + 5, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 4, + 6, + 6, + 5, + 5, + 4, + 5, + 3, + 5, + 5, + 5, + 7, + 2, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 3, + 6, + 6, + 7, + 5, + 7, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 8, + 8, + 8, + 9, + 62, + 34, + 34, + 34, + 42, + 55, + 24, + 26, + 24, + 34, + 34, + 34, + 34, + 23, + 42, + 55, + 24, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 33, + 33, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 37, + 42, + 56, + 24, + 24, + 63, + 34, + 34, + 37, + 42, + 56, + 24, + 26, + 33, + 33, + 34, + 37, + 333, + 24, + 34, + 34, + 34, + 36, + 42, + 55, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 62, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 24, + 34, + 34, + 37, + 42, + 55, + 24, + 71, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 71, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 65, + 62, + 62, + 34, + 34, + 33, + 37, + 42, + 60, + 62, + 71, + 34, + 34, + 34, + 24, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 37, + 56, + 363, + 24, + 26, + 34, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 31, + 26, + 63, + 34, + 34, + 37, + 42, + 56, + 62, + 24, + 22, + 34, + 34, + 34, + 63, + 42, + 56, + 57, + 62, + 9, + 2, + 9, + 2, + 9, + 26, + 34, + 34, + 34, + 37, + 56, + 57, + 34, + 34, + 63, + 34, + 37, + 42, + 52, + 2, + 71, + 24, + 34, + 33, + 63, + 37, + 42, + 60, + 62, + 26, + 24, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 9, + 24, + 24, + 22, + 62, + 34, + 34, + 34, + 33, + 42, + 243, + 52, + 24, + 26, + 24, + 34, + 34, + 33, + 34, + 37, + 56, + 55, + 65, + 62, + 34, + 34, + 34, + 38, + 525, + 363, + 62, + 357, + 62, + 24, + 33, + 34, + 34, + 34, + 42, + 56, + 55, + 500, + 23, + 34, + 34, + 33, + 42, + 42, + 55, + 24, + 62, + 24, + 24, + 2, + 24, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 63, + 34, + 42, + 56, + 55, + 65, + 62, + 24, + 34, + 34, + 34, + 37, + 56, + 55, + 24, + 65, + 24, + 24, + 33, + 34, + 34, + 36, + 42, + 52, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 57, + 62, + 65, + 62, + 33, + 34, + 34, + 38, + 42, + 55, + 24, + 26, + 33, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 9, + 9, + 9, + 24, + 33, + 34, + 34, + 37, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 2, + 56, + 57, + 26, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 24, + 33, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 24, + 34, + 34, + 33, + 36, + 42, + 527, + 62, + 24, + 62, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 71, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 62, + 24, + 34, + 34, + 34, + 42, + 42, + 55, + 62, + 26, + 34, + 33, + 24, + 24, + 42, + 56, + 24, + 62, + 26, + 62, + 31, + 9, + 62, + 23, + 62, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 62, + 24, + 24, + 71, + 62, + 34, + 34, + 37, + 42, + 56, + 363, + 62, + 65, + 24, + 34, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 24, + 26, + 34, + 63, + 34, + 34, + 42, + 56, + 55, + 24, + 357, + 9, + 2, + 235, + 528, + 306, + 533, + 71, + 24, + 24, + 63, + 34, + 33, + 37, + 42, + 363, + 9, + 24, + 62, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 24, + 26, + 24, + 34, + 34, + 42, + 56, + 24, + 71, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 26, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 57, + 2, + 62, + 34, + 34, + 34, + 42, + 56, + 57, + 65, + 34, + 33, + 34, + 37, + 56, + 55, + 24, + 26, + 34, + 34, + 34, + 63, + 42, + 56, + 52, + 24, + 62, + 24, + 34, + 68, + 42, + 56, + 62, + 62, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 26, + 24, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 2, + 62, + 62, + 34, + 63, + 34, + 37, + 42, + 56, + 55, + 65, + 62, + 63, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 63, + 34, + 33, + 34, + 42, + 56, + 57, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 81, + 537, + 98, + 543, + 2, + 124, + 26, + 24, + 63, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 34, + 34, + 33, + 34, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 34, + 63, + 37, + 42, + 56, + 62, + 62, + 24, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 55, + 26, + 33, + 33, + 34, + 33, + 42, + 56, + 55, + 62, + 65, + 24, + 24, + 34, + 63, + 34, + 34, + 37, + 42, + 55, + 2, + 24, + 33, + 34, + 34, + 37, + 56, + 55, + 24, + 26, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 9, + 24, + 33, + 34, + 34, + 68, + 42, + 56, + 55, + 62, + 9, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 57, + 62, + 22, + 24, + 33, + 63, + 34, + 37, + 42, + 56, + 24, + 71, + 34, + 34, + 34, + 68, + 42, + 56, + 62, + 62, + 34, + 33, + 34, + 33, + 42, + 40, + 55, + 62, + 62, + 71, + 31, + 63, + 33, + 34, + 36, + 42, + 56, + 57, + 71, + 62, + 2, + 24, + 63, + 34, + 33, + 37, + 42, + 55, + 62, + 9, + 9, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 71, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 33, + 34, + 68, + 42, + 56, + 57, + 24, + 26, + 24, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 62, + 71, + 24, + 22, + 24, + 63, + 34, + 33, + 34, + 42, + 42, + 56, + 55, + 24, + 26, + 62, + 34, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 63, + 42, + 55, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 60, + 57, + 24, + 65, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 57, + 24, + 9, + 24, + 34, + 34, + 34, + 42, + 42, + 60, + 57, + 24, + 24, + 2, + 9, + 34, + 34, + 34, + 34, + 42, + 42, + 60, + 24, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 9, + 24, + 24, + 34, + 34, + 68, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 34, + 34, + 390, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 24, + 71, + 63, + 34, + 33, + 42, + 56, + 55, + 62, + 62, + 65, + 34, + 34, + 33, + 37, + 42, + 363, + 62, + 31, + 26, + 62, + 34, + 34, + 34, + 42, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 55, + 24, + 26, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 2, + 2, + 2, + 2, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 169, + 140, + 140, + 3, + 3, + 5, + 6, + 5, + 61, + 61, + 61, + 6, + 5, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 3, + 7, + 6, + 4, + 6, + 7, + 6, + 7, + 5, + 5, + 6, + 5, + 171, + 42, + 42, + 9, + 33, + 34, + 42, + 42, + 55, + 24, + 62, + 34, + 34, + 42, + 56, + 512, + 71, + 24, + 34, + 33, + 68, + 42, + 56, + 57, + 22, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 55, + 9, + 24, + 34, + 34, + 34, + 42, + 42, + 60, + 62, + 9, + 71, + 34, + 9, + 57, + 65, + 24, + 24, + 34, + 33, + 33, + 42, + 56, + 55, + 62, + 24, + 33, + 34, + 33, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 34, + 61, + 61, + 61, + 61, + 61, + 26, + 34, + 37, + 56, + 65, + 34, + 42, + 56, + 9, + 42, + 56, + 37, + 62, + 34, + 24, + 26, + 24, + 57, + 34, + 34, + 42, + 544, + 26, + 34, + 42, + 56, + 363, + 33, + 34, + 42, + 65, + 33, + 42, + 377, + 34, + 33, + 37, + 24, + 34, + 34, + 363, + 9, + 9, + 34, + 62, + 24, + 37, + 42, + 56, + 26, + 62, + 33, + 33, + 37, + 56, + 55, + 24, + 26, + 62, + 33, + 34, + 34, + 37, + 55, + 62, + 34, + 34, + 34, + 37, + 55, + 24, + 26, + 62, + 22, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 34, + 33, + 33, + 37, + 56, + 60, + 62, + 62, + 71, + 24, + 2, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 71, + 62, + 34, + 34, + 34, + 34, + 42, + 44, + 55, + 22, + 24, + 24, + 62, + 24, + 62, + 26, + 62, + 34, + 33, + 34, + 37, + 42, + 60, + 57, + 26, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 24, + 26, + 24, + 33, + 34, + 37, + 42, + 56, + 24, + 24, + 33, + 34, + 37, + 56, + 245, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 33, + 63, + 33, + 333, + 56, + 357, + 62, + 34, + 33, + 34, + 34, + 42, + 56, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 36, + 42, + 56, + 57, + 24, + 34, + 34, + 33, + 33, + 42, + 56, + 55, + 24, + 65, + 33, + 34, + 34, + 37, + 42, + 56, + 31, + 62, + 62, + 34, + 34, + 34, + 37, + 42, + 245, + 62, + 26, + 33, + 34, + 33, + 68, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 2, + 24, + 33, + 34, + 34, + 42, + 56, + 52, + 24, + 24, + 26, + 26, + 33, + 63, + 34, + 42, + 56, + 55, + 24, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 363, + 62, + 62, + 62, + 23, + 34, + 34, + 34, + 42, + 56, + 60, + 26, + 24, + 34, + 33, + 34, + 34, + 42, + 56, + 245, + 57, + 33, + 34, + 34, + 37, + 42, + 55, + 24, + 24, + 34, + 34, + 63, + 34, + 42, + 245, + 62, + 545, + 9, + 18, + 62, + 62, + 33, + 34, + 34, + 37, + 42, + 52, + 57, + 24, + 26, + 34, + 34, + 63, + 390, + 42, + 55, + 62, + 2, + 62, + 33, + 34, + 34, + 37, + 42, + 52, + 24, + 26, + 33, + 34, + 34, + 42, + 56, + 55, + 24, + 62, + 34, + 34, + 34, + 2, + 42, + 56, + 57, + 62, + 34, + 63, + 33, + 37, + 42, + 55, + 24, + 63, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 62, + 34, + 34, + 33, + 42, + 56, + 57, + 26, + 34, + 63, + 33, + 37, + 42, + 55, + 24, + 24, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 26, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 62, + 62, + 63, + 34, + 34, + 34, + 42, + 310, + 245, + 62, + 62, + 26, + 63, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 24, + 61, + 24, + 24, + 24, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 9, + 24, + 34, + 63, + 37, + 333, + 56, + 55, + 23, + 62, + 33, + 34, + 33, + 37, + 42, + 56, + 55, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 332, + 111, + 9, + 9, + 9, + 9, + 29, + 62, + 33, + 34, + 56, + 55, + 9, + 56, + 57, + 62, + 22, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 57, + 9, + 62, + 34, + 34, + 34, + 42, + 56, + 24, + 24, + 24, + 34, + 33, + 34, + 37, + 56, + 24, + 34, + 34, + 34, + 42, + 56, + 24, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 313, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 33, + 34, + 34, + 68, + 42, + 52, + 24, + 26, + 34, + 34, + 33, + 37, + 42, + 55, + 24, + 26, + 34, + 34, + 33, + 34, + 42, + 52, + 62, + 24, + 26, + 34, + 34, + 33, + 42, + 42, + 55, + 24, + 22, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 62, + 24, + 33, + 37, + 42, + 56, + 55, + 24, + 311, + 24, + 62, + 34, + 33, + 34, + 36, + 42, + 56, + 57, + 9, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 34, + 63, + 34, + 36, + 42, + 57, + 26, + 62, + 34, + 33, + 34, + 37, + 56, + 57, + 9, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 26, + 34, + 33, + 34, + 33, + 42, + 56, + 57, + 62, + 65, + 24, + 34, + 63, + 34, + 33, + 42, + 56, + 55, + 23, + 2, + 63, + 34, + 34, + 34, + 42, + 42, + 55, + 62, + 24, + 2, + 26, + 62, + 34, + 33, + 34, + 37, + 42, + 52, + 24, + 62, + 24, + 9, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 525, + 363, + 9, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 33, + 33, + 34, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 33, + 37, + 42, + 52, + 57, + 62, + 9, + 24, + 34, + 34, + 33, + 42, + 56, + 60, + 62, + 2, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 24, + 62, + 24, + 34, + 34, + 34, + 57, + 24, + 65, + 62, + 33, + 34, + 34, + 34, + 42, + 40, + 55, + 62, + 2, + 24, + 34, + 34, + 33, + 37, + 42, + 56, + 49, + 24, + 377, + 24, + 34, + 34, + 33, + 63, + 37, + 42, + 56, + 57, + 9, + 26, + 24, + 62, + 33, + 24, + 33, + 42, + 42, + 55, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 55, + 62, + 62, + 26, + 24, + 34, + 34, + 63, + 33, + 42, + 56, + 55, + 62, + 26, + 34, + 33, + 34, + 34, + 68, + 42, + 52, + 24, + 62, + 34, + 34, + 37, + 42, + 57, + 23, + 34, + 33, + 34, + 42, + 56, + 9, + 34, + 34, + 63, + 63, + 37, + 42, + 56, + 62, + 62, + 24, + 24, + 2, + 24, + 34, + 33, + 36, + 42, + 42, + 55, + 24, + 22, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 22, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 71, + 34, + 33, + 34, + 34, + 42, + 56, + 57, + 62, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 24, + 34, + 33, + 33, + 37, + 42, + 56, + 55, + 26, + 24, + 33, + 34, + 34, + 34, + 42, + 56, + 62, + 26, + 24, + 63, + 34, + 34, + 34, + 42, + 42, + 363, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 141, + 140, + 140, + 169, + 169, + 139, + 139, + 140, + 139, + 169, + 139, + 139, + 140, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 142, + 142, + 142, + 2, + 2, + 2, + 3, + 3, + 7, + 24, + 26, + 34, + 61, + 62, + 9, + 34, + 24, + 34, + 24, + 34, + 34, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 71, + 63, + 34, + 68, + 42, + 9, + 26, + 34, + 34, + 34, + 37, + 42, + 57, + 24, + 62, + 34, + 34, + 34, + 37, + 56, + 55, + 26, + 24, + 34, + 33, + 34, + 36, + 42, + 55, + 24, + 26, + 63, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 22, + 24, + 24, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 57, + 2, + 62, + 24, + 34, + 33, + 37, + 56, + 55, + 24, + 34, + 63, + 42, + 56, + 62, + 9, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 62, + 62, + 34, + 33, + 33, + 56, + 55, + 62, + 62, + 34, + 34, + 37, + 42, + 55, + 9, + 34, + 33, + 34, + 68, + 42, + 363, + 57, + 24, + 24, + 24, + 24, + 34, + 63, + 34, + 42, + 56, + 363, + 24, + 2, + 62, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 24, + 24, + 34, + 33, + 34, + 37, + 56, + 57, + 62, + 62, + 24, + 63, + 34, + 34, + 37, + 42, + 56, + 57, + 23, + 26, + 24, + 33, + 33, + 33, + 37, + 42, + 56, + 62, + 9, + 24, + 62, + 34, + 34, + 34, + 502, + 56, + 57, + 26, + 62, + 63, + 34, + 33, + 37, + 56, + 57, + 24, + 63, + 34, + 33, + 37, + 42, + 52, + 24, + 62, + 26, + 62, + 33, + 34, + 34, + 42, + 56, + 57, + 24, + 33, + 68, + 42, + 52, + 24, + 26, + 62, + 33, + 34, + 37, + 42, + 2, + 33, + 33, + 33, + 34, + 42, + 55, + 24, + 34, + 34, + 42, + 56, + 57, + 26, + 34, + 34, + 34, + 68, + 56, + 24, + 24, + 24, + 34, + 34, + 63, + 34, + 42, + 56, + 24, + 9, + 24, + 34, + 34, + 63, + 34, + 68, + 42, + 52, + 62, + 22, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 34, + 34, + 34, + 33, + 42, + 56, + 57, + 2, + 34, + 34, + 34, + 34, + 56, + 55, + 24, + 24, + 71, + 62, + 34, + 34, + 37, + 42, + 56, + 55, + 26, + 34, + 63, + 33, + 34, + 42, + 56, + 55, + 24, + 24, + 2, + 24, + 33, + 34, + 42, + 56, + 363, + 34, + 33, + 37, + 42, + 363, + 24, + 378, + 9, + 24, + 34, + 34, + 63, + 55, + 62, + 34, + 33, + 34, + 42, + 56, + 9, + 24, + 34, + 33, + 63, + 42, + 56, + 55, + 24, + 24, + 33, + 34, + 33, + 42, + 56, + 55, + 24, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 24, + 62, + 34, + 37, + 42, + 57, + 26, + 34, + 34, + 34, + 37, + 56, + 57, + 33, + 34, + 33, + 42, + 55, + 24, + 34, + 33, + 33, + 42, + 52, + 24, + 24, + 34, + 34, + 42, + 56, + 55, + 24, + 34, + 34, + 34, + 34, + 37, + 42, + 52, + 62, + 22, + 24, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 62, + 34, + 63, + 34, + 42, + 42, + 55, + 62, + 9, + 24, + 62, + 24, + 34, + 33, + 33, + 42, + 56, + 55, + 62, + 9, + 62, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 33, + 34, + 34, + 390, + 56, + 55, + 62, + 2, + 113, + 9, + 2, + 26, + 24, + 62, + 63, + 34, + 37, + 42, + 546, + 62, + 34, + 34, + 37, + 56, + 55, + 24, + 9, + 34, + 34, + 63, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 37, + 42, + 57, + 62, + 2, + 34, + 33, + 333, + 24, + 62, + 34, + 34, + 63, + 42, + 60, + 414, + 31, + 33, + 57, + 33, + 33, + 34, + 37, + 42, + 56, + 57, + 26, + 2, + 63, + 34, + 68, + 42, + 55, + 26, + 62, + 63, + 34, + 33, + 34, + 37, + 42, + 52, + 57, + 2, + 24, + 34, + 34, + 63, + 42, + 42, + 55, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 31, + 34, + 34, + 37, + 42, + 60, + 62, + 26, + 63, + 63, + 63, + 36, + 56, + 363, + 24, + 24, + 26, + 63, + 33, + 34, + 37, + 56, + 55, + 24, + 22, + 24, + 34, + 63, + 34, + 42, + 56, + 9, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 34, + 34, + 68, + 42, + 55, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 378, + 9, + 9, + 2, + 548, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 34, + 34, + 34, + 37, + 56, + 55, + 62, + 24, + 9, + 34, + 34, + 34, + 37, + 42, + 57, + 62, + 34, + 63, + 37, + 42, + 55, + 2, + 24, + 62, + 33, + 33, + 24, + 33, + 42, + 56, + 57, + 26, + 33, + 19, + 24, + 34, + 33, + 63, + 37, + 42, + 56, + 57, + 65, + 24, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 63, + 42, + 60, + 24, + 2, + 62, + 34, + 33, + 34, + 42, + 56, + 55, + 549, + 24, + 62, + 34, + 33, + 42, + 42, + 60, + 62, + 26, + 24, + 33, + 34, + 33, + 42, + 56, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 62, + 62, + 34, + 34, + 34, + 34, + 42, + 42, + 52, + 57, + 406, + 62, + 24, + 24, + 26, + 62, + 34, + 33, + 34, + 37, + 42, + 55, + 9, + 100, + 366, + 9, + 24, + 62, + 22, + 24, + 34, + 33, + 34, + 63, + 42, + 52, + 57, + 24, + 26, + 62, + 33, + 33, + 37, + 42, + 56, + 57, + 26, + 34, + 34, + 34, + 37, + 56, + 52, + 24, + 62, + 33, + 33, + 68, + 42, + 55, + 9, + 62, + 33, + 63, + 37, + 42, + 56, + 57, + 62, + 24, + 62, + 34, + 34, + 37, + 42, + 55, + 62, + 26, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 71, + 24, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 62, + 63, + 34, + 34, + 37, + 42, + 42, + 363, + 9, + 62, + 34, + 34, + 34, + 42, + 42, + 363, + 24, + 9, + 62, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 34, + 34, + 34, + 42, + 56, + 363, + 62, + 33, + 34, + 63, + 37, + 42, + 55, + 26, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 550, + 111, + 232, + 113, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 9, + 140, + 139, + 139, + 169, + 169, + 140, + 140, + 140, + 139, + 169, + 169, + 169, + 169, + 169, + 140, + 139, + 140, + 140, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 6, + 3, + 5, + 4, + 5, + 4, + 6, + 7, + 6, + 5, + 7, + 5, + 6, + 6, + 5, + 5, + 7, + 7, + 5, + 5, + 5, + 5, + 3, + 5, + 2, + 5, + 7, + 7, + 5, + 5, + 6, + 5, + 3, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 5, + 5, + 4, + 5, + 7, + 6, + 7, + 5, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 6, + 5, + 7, + 7, + 5, + 7, + 7, + 6, + 5, + 6, + 6, + 5, + 7, + 5, + 6, + 6, + 6, + 4, + 5, + 5, + 5, + 5, + 4, + 5, + 5, + 6, + 6, + 6, + 5, + 6, + 5, + 7, + 6, + 6, + 2, + 5, + 5, + 6, + 5, + 6, + 7, + 7, + 5, + 5, + 5, + 6, + 7, + 6, + 2, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 7, + 6, + 5, + 5, + 6, + 7, + 5, + 5, + 4, + 7, + 6, + 7, + 6, + 6, + 4, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 6, + 8, + 8, + 8, + 8, + 8, + 2, + 9, + 10, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 62, + 24, + 34, + 34, + 37, + 42, + 55, + 23, + 9, + 24, + 24, + 34, + 34, + 42, + 527, + 357, + 23, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 42, + 55, + 24, + 62, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 9, + 62, + 34, + 34, + 33, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 18, + 111, + 388, + 9, + 2, + 9, + 9, + 9, + 9, + 2, + 2, + 138, + 135, + 142, + 3, + 7, + 61, + 61, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 140, + 169, + 140, + 169, + 139, + 169, + 139, + 139, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 6, + 6, + 6, + 5, + 8, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 363, + 57, + 24, + 61, + 10, + 10, + 10, + 34, + 37, + 42, + 56, + 57, + 551, + 357, + 24, + 33, + 42, + 57, + 24, + 34, + 42, + 42, + 363, + 57, + 24, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 406, + 24, + 62, + 22, + 63, + 34, + 34, + 37, + 56, + 60, + 62, + 19, + 24, + 24, + 34, + 33, + 42, + 56, + 57, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 9, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 141, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 140, + 139, + 140, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 142, + 142, + 142, + 142, + 2, + 2, + 3, + 5, + 5, + 7, + 4, + 3, + 5, + 6, + 5, + 7, + 7, + 5, + 5, + 5, + 7, + 5, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 170, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 6, + 3, + 3, + 4, + 7, + 7, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 7, + 5, + 6, + 6, + 6, + 5, + 5, + 7, + 6, + 6, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 6, + 7, + 6, + 6, + 5, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 4, + 2, + 6, + 6, + 4, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 170, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 4, + 5, + 5, + 7, + 6, + 4, + 7, + 6, + 5, + 6, + 7, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 3, + 4, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 4, + 5, + 5, + 8, + 8, + 8, + 8, + 2, + 9, + 9, + 553, + 195, + 213, + 510, + 9, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 34, + 3, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 7, + 33, + 26, + 63, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 33, + 37, + 42, + 56, + 55, + 24, + 9, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 377, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 2, + 24, + 554, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 167, + 139, + 169, + 140, + 169, + 140, + 140, + 169, + 140, + 169, + 169, + 169, + 139, + 140, + 169, + 169, + 139, + 139, + 140, + 140, + 139, + 140, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 3, + 7, + 6, + 5, + 4, + 7, + 5, + 6, + 5, + 5, + 5, + 6, + 4, + 4, + 5, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 5, + 7, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 3, + 5, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 7, + 7, + 61, + 6, + 6, + 5, + 5, + 5, + 6, + 2, + 6, + 6, + 6, + 5, + 5, + 7, + 5, + 5, + 4, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 5, + 7, + 5, + 5, + 5, + 3, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 7, + 7, + 5, + 5, + 6, + 6, + 2, + 5, + 4, + 7, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 7, + 6, + 7, + 5, + 5, + 4, + 4, + 6, + 6, + 7, + 6, + 6, + 3, + 5, + 7, + 6, + 6, + 5, + 7, + 6, + 5, + 7, + 7, + 7, + 5, + 5, + 8, + 8, + 354, + 9, + 9, + 2, + 471, + 409, + 160, + 162, + 555, + 2, + 556, + 227, + 229, + 557, + 226, + 306, + 558, + 24, + 62, + 26, + 24, + 34, + 33, + 33, + 37, + 42, + 55, + 62, + 24, + 24, + 34, + 33, + 33, + 42, + 42, + 55, + 62, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 71, + 62, + 33, + 34, + 34, + 37, + 42, + 55, + 26, + 37, + 34, + 42, + 34, + 42, + 57, + 62, + 63, + 42, + 55, + 71, + 33, + 56, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 400, + 9, + 34, + 56, + 62, + 26, + 34, + 34, + 37, + 42, + 55, + 2, + 24, + 34, + 42, + 56, + 57, + 26, + 24, + 34, + 34, + 26, + 34, + 34, + 42, + 24, + 24, + 34, + 42, + 55, + 34, + 34, + 42, + 56, + 24, + 24, + 33, + 33, + 333, + 24, + 24, + 33, + 34, + 56, + 62, + 34, + 34, + 56, + 24, + 33, + 34, + 34, + 42, + 57, + 9, + 34, + 34, + 26, + 33, + 37, + 52, + 62, + 26, + 24, + 33, + 34, + 42, + 57, + 24, + 24, + 63, + 34, + 37, + 55, + 26, + 34, + 34, + 34, + 68, + 56, + 62, + 26, + 34, + 56, + 55, + 26, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 33, + 42, + 56, + 57, + 26, + 26, + 63, + 34, + 63, + 37, + 56, + 57, + 23, + 62, + 34, + 33, + 56, + 55, + 554, + 9, + 34, + 33, + 37, + 56, + 24, + 34, + 42, + 56, + 62, + 71, + 357, + 34, + 33, + 42, + 43, + 34, + 363, + 9, + 26, + 24, + 34, + 37, + 55, + 22, + 24, + 26, + 62, + 34, + 34, + 56, + 57, + 34, + 34, + 33, + 42, + 56, + 55, + 24, + 62, + 34, + 37, + 56, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 363, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 113, + 367, + 9, + 24, + 34, + 37, + 42, + 57, + 24, + 33, + 34, + 37, + 56, + 26, + 34, + 34, + 42, + 57, + 24, + 33, + 60, + 313, + 34, + 56, + 24, + 2, + 63, + 63, + 42, + 62, + 34, + 34, + 37, + 33, + 42, + 313, + 33, + 34, + 56, + 62, + 24, + 34, + 37, + 55, + 26, + 34, + 34, + 42, + 56, + 55, + 62, + 33, + 63, + 34, + 37, + 42, + 55, + 24, + 34, + 34, + 34, + 37, + 56, + 57, + 62, + 33, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 24, + 71, + 34, + 34, + 33, + 37, + 42, + 56, + 52, + 24, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 57, + 62, + 26, + 24, + 24, + 24, + 34, + 34, + 42, + 42, + 55, + 26, + 34, + 34, + 42, + 56, + 57, + 62, + 33, + 34, + 33, + 37, + 42, + 55, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 405, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 142, + 142, + 142, + 2, + 3, + 2, + 3, + 4, + 6, + 6, + 6, + 6, + 5, + 4, + 6, + 5, + 7, + 6, + 7, + 5, + 6, + 6, + 7, + 6, + 6, + 4, + 6, + 5, + 5, + 6, + 6, + 6, + 170, + 5, + 6, + 5, + 5, + 6, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 4, + 7, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 6, + 6, + 5, + 7, + 5, + 4, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 7, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 4, + 7, + 6, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 7, + 6, + 5, + 7, + 5, + 6, + 6, + 6, + 7, + 5, + 5, + 5, + 6, + 5, + 4, + 5, + 6, + 7, + 5, + 3, + 5, + 5, + 5, + 6, + 5, + 4, + 5, + 4, + 5, + 7, + 5, + 5, + 6, + 5, + 5, + 8, + 8, + 8, + 8, + 9, + 2, + 24, + 63, + 33, + 33, + 42, + 56, + 55, + 62, + 327, + 24, + 33, + 34, + 33, + 68, + 56, + 55, + 24, + 26, + 34, + 33, + 33, + 24, + 42, + 55, + 62, + 24, + 65, + 71, + 34, + 63, + 34, + 68, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 48, + 55, + 24, + 34, + 34, + 33, + 68, + 42, + 42, + 55, + 9, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 62, + 34, + 34, + 34, + 37, + 55, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 26, + 33, + 34, + 34, + 37, + 42, + 34, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 3, + 3, + 3, + 5, + 5, + 7, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 7, + 6, + 5, + 2, + 6, + 6, + 6, + 5, + 24, + 34, + 42, + 62, + 34, + 37, + 62, + 26, + 34, + 34, + 34, + 40, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 57, + 24, + 65, + 24, + 34, + 37, + 42, + 56, + 55, + 62, + 62, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 34, + 9, + 62, + 34, + 42, + 56, + 57, + 62, + 71, + 24, + 33, + 34, + 34, + 42, + 55, + 34, + 63, + 37, + 42, + 363, + 24, + 2, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 62, + 62, + 26, + 24, + 24, + 34, + 63, + 33, + 37, + 42, + 52, + 57, + 26, + 34, + 34, + 34, + 68, + 42, + 56, + 24, + 62, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 71, + 24, + 24, + 63, + 34, + 33, + 42, + 56, + 55, + 9, + 24, + 63, + 34, + 34, + 34, + 37, + 42, + 55, + 57, + 71, + 24, + 34, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 26, + 62, + 63, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 57, + 26, + 63, + 63, + 34, + 33, + 37, + 42, + 56, + 57, + 62, + 65, + 33, + 33, + 34, + 37, + 42, + 56, + 55, + 24, + 550, + 9, + 62, + 24, + 65, + 34, + 34, + 34, + 37, + 42, + 52, + 57, + 24, + 9, + 24, + 24, + 33, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 559, + 55, + 24, + 65, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 65, + 62, + 24, + 10, + 24, + 62, + 71, + 62, + 33, + 34, + 33, + 34, + 42, + 56, + 57, + 24, + 22, + 34, + 34, + 34, + 34, + 333, + 56, + 57, + 24, + 9, + 113, + 560, + 26, + 63, + 34, + 33, + 34, + 42, + 56, + 55, + 57, + 24, + 22, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 24, + 34, + 34, + 34, + 36, + 42, + 55, + 24, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 2, + 34, + 34, + 34, + 34, + 37, + 42, + 55, + 24, + 9, + 24, + 34, + 34, + 68, + 42, + 56, + 57, + 24, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 33, + 33, + 42, + 56, + 55, + 24, + 65, + 65, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 357, + 71, + 34, + 34, + 34, + 37, + 42, + 56, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 34, + 63, + 34, + 34, + 42, + 56, + 62, + 24, + 34, + 34, + 37, + 42, + 56, + 2, + 34, + 33, + 34, + 42, + 42, + 52, + 62, + 24, + 62, + 34, + 34, + 42, + 55, + 23, + 26, + 24, + 34, + 63, + 63, + 37, + 42, + 56, + 245, + 24, + 71, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 140, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 141, + 140, + 139, + 139, + 139, + 139, + 140, + 139, + 140, + 142, + 142, + 142, + 2, + 3, + 3, + 3, + 3, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 7, + 6, + 6, + 5, + 3, + 6, + 5, + 6, + 6, + 2, + 6, + 5, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 6, + 7, + 5, + 5, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 4, + 6, + 6, + 9, + 34, + 34, + 34, + 33, + 37, + 42, + 56, + 55, + 414, + 24, + 33, + 24, + 42, + 358, + 57, + 24, + 24, + 62, + 34, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 3, + 7, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 5, + 6, + 5, + 5, + 4, + 6, + 5, + 7, + 6, + 5, + 7, + 6, + 6, + 6, + 6, + 6, + 5, + 7, + 6, + 7, + 5, + 6, + 5, + 6, + 61, + 61, + 61, + 61, + 61, + 113, + 400, + 367, + 9, + 9, + 235, + 197, + 562, + 147, + 563, + 237, + 225, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 9, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 19, + 62, + 24, + 33, + 33, + 34, + 42, + 56, + 57, + 9, + 33, + 34, + 34, + 34, + 42, + 52, + 62, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 26, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 42, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 9, + 9, + 24, + 24, + 9, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 33, + 63, + 42, + 56, + 55, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 24, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 313, + 24, + 34, + 33, + 33, + 37, + 42, + 56, + 57, + 26, + 24, + 62, + 24, + 24, + 24, + 26, + 33, + 34, + 63, + 34, + 42, + 363, + 24, + 29, + 34, + 34, + 34, + 34, + 34, + 42, + 363, + 551, + 65, + 62, + 62, + 33, + 34, + 37, + 45, + 57, + 22, + 71, + 24, + 34, + 34, + 34, + 37, + 333, + 52, + 55, + 9, + 24, + 33, + 33, + 33, + 68, + 42, + 52, + 24, + 65, + 71, + 63, + 42, + 56, + 245, + 57, + 24, + 9, + 24, + 34, + 33, + 68, + 42, + 56, + 55, + 62, + 24, + 2, + 22, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 24, + 24, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 24, + 34, + 33, + 34, + 42, + 56, + 24, + 26, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 33, + 33, + 34, + 37, + 42, + 57, + 24, + 34, + 34, + 34, + 37, + 56, + 57, + 24, + 26, + 24, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 2, + 111, + 9, + 26, + 62, + 34, + 34, + 24, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 33, + 34, + 63, + 333, + 56, + 9, + 26, + 62, + 24, + 34, + 34, + 34, + 33, + 42, + 56, + 57, + 26, + 62, + 34, + 34, + 34, + 68, + 42, + 52, + 62, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 26, + 34, + 34, + 33, + 68, + 42, + 56, + 55, + 24, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 26, + 34, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 9, + 24, + 34, + 63, + 34, + 37, + 56, + 57, + 24, + 24, + 71, + 34, + 34, + 34, + 34, + 42, + 358, + 24, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 113, + 232, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 140, + 139, + 140, + 139, + 139, + 140, + 140, + 141, + 140, + 140, + 169, + 140, + 139, + 140, + 140, + 139, + 139, + 169, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 2, + 6, + 6, + 7, + 5, + 5, + 5, + 6, + 5, + 5, + 4, + 5, + 5, + 7, + 6, + 7, + 6, + 3, + 6, + 6, + 5, + 4, + 6, + 6, + 5, + 5, + 4, + 6, + 2, + 6, + 7, + 5, + 6, + 6, + 7, + 5, + 5, + 7, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 6, + 7, + 5, + 6, + 6, + 5, + 7, + 5, + 5, + 6, + 7, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 6, + 5, + 4, + 6, + 6, + 5, + 5, + 6, + 4, + 6, + 6, + 5, + 5, + 5, + 7, + 6, + 7, + 7, + 6, + 6, + 5, + 6, + 7, + 6, + 5, + 5, + 6, + 5, + 7, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 6, + 6, + 6, + 4, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 5, + 6, + 4, + 6, + 5, + 7, + 7, + 6, + 6, + 5, + 5, + 7, + 5, + 7, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 7, + 6, + 354, + 8, + 8, + 9, + 9, + 65, + 24, + 24, + 65, + 24, + 24, + 24, + 34, + 34, + 42, + 40, + 55, + 62, + 24, + 34, + 34, + 34, + 68, + 42, + 55, + 24, + 9, + 24, + 33, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 65, + 24, + 34, + 34, + 33, + 36, + 42, + 56, + 55, + 62, + 567, + 9, + 9, + 29, + 34, + 34, + 33, + 34, + 37, + 245, + 24, + 24, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 26, + 34, + 34, + 34, + 34, + 333, + 42, + 56, + 62, + 24, + 26, + 24, + 34, + 34, + 63, + 34, + 42, + 56, + 55, + 62, + 24, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 3, + 34, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 24, + 357, + 62, + 34, + 2, + 42, + 55, + 9, + 143, + 162, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 167, + 167, + 167, + 140, + 141, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 169, + 140, + 169, + 142, + 3, + 3, + 2, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 4, + 7, + 5, + 5, + 7, + 5, + 5, + 6, + 6, + 6, + 3, + 7, + 5, + 6, + 5, + 6, + 2, + 4, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 2, + 6, + 5, + 5, + 7, + 6, + 2, + 5, + 3, + 5, + 5, + 7, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 6, + 7, + 7, + 5, + 6, + 5, + 7, + 4, + 5, + 6, + 5, + 6, + 4, + 7, + 7, + 6, + 5, + 6, + 6, + 7, + 6, + 6, + 6, + 6, + 6, + 354, + 9, + 9, + 9, + 71, + 33, + 34, + 34, + 37, + 56, + 57, + 24, + 63, + 34, + 42, + 56, + 26, + 34, + 34, + 42, + 56, + 62, + 34, + 42, + 56, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 532, + 24, + 33, + 34, + 42, + 56, + 471, + 472, + 308, + 26, + 56, + 415, + 34, + 37, + 55, + 26, + 24, + 24, + 24, + 34, + 57, + 9, + 34, + 34, + 42, + 9, + 34, + 42, + 56, + 57, + 71, + 34, + 34, + 37, + 42, + 55, + 62, + 9, + 33, + 34, + 34, + 42, + 56, + 57, + 34, + 63, + 34, + 56, + 57, + 26, + 24, + 26, + 24, + 24, + 33, + 34, + 37, + 42, + 57, + 24, + 34, + 34, + 33, + 42, + 55, + 62, + 9, + 24, + 24, + 34, + 34, + 33, + 24, + 42, + 56, + 57, + 26, + 34, + 34, + 34, + 37, + 42, + 60, + 62, + 31, + 34, + 34, + 34, + 34, + 42, + 56, + 363, + 62, + 26, + 24, + 34, + 36, + 42, + 56, + 55, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 52, + 57, + 62, + 26, + 62, + 33, + 34, + 34, + 68, + 42, + 52, + 9, + 26, + 33, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 33, + 34, + 33, + 37, + 56, + 23, + 62, + 62, + 34, + 33, + 34, + 37, + 56, + 245, + 24, + 24, + 34, + 34, + 42, + 56, + 34, + 34, + 33, + 34, + 34, + 42, + 56, + 57, + 9, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 71, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 24, + 26, + 62, + 34, + 34, + 34, + 68, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 55, + 24, + 10, + 24, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 62, + 62, + 34, + 63, + 34, + 34, + 42, + 57, + 9, + 34, + 37, + 62, + 42, + 56, + 55, + 62, + 22, + 55, + 62, + 62, + 24, + 33, + 33, + 34, + 37, + 57, + 9, + 62, + 24, + 33, + 34, + 34, + 33, + 42, + 56, + 55, + 26, + 24, + 68, + 42, + 56, + 57, + 24, + 29, + 62, + 63, + 33, + 33, + 37, + 42, + 56, + 55, + 24, + 62, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 2, + 24, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 9, + 24, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 2, + 24, + 62, + 24, + 24, + 24, + 62, + 63, + 33, + 63, + 37, + 42, + 52, + 57, + 62, + 26, + 63, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 71, + 62, + 33, + 34, + 34, + 37, + 42, + 56, + 327, + 24, + 33, + 34, + 34, + 42, + 56, + 24, + 24, + 26, + 34, + 34, + 34, + 37, + 56, + 55, + 24, + 62, + 24, + 33, + 34, + 34, + 42, + 56, + 57, + 24, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 2, + 61, + 139, + 139, + 140, + 139, + 139, + 141, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 141, + 139, + 140, + 139, + 140, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 142, + 142, + 2, + 2, + 3, + 3, + 3, + 6, + 5, + 5, + 7, + 5, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 7, + 6, + 2, + 5, + 6, + 5, + 4, + 2, + 7, + 5, + 7, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 4, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 2, + 6, + 5, + 2, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 7, + 6, + 6, + 6, + 3, + 5, + 6, + 6, + 5, + 3, + 6, + 5, + 6, + 3, + 6, + 6, + 5, + 7, + 5, + 6, + 291, + 5, + 7, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 7, + 7, + 6, + 5, + 6, + 6, + 6, + 7, + 6, + 5, + 6, + 3, + 5, + 6, + 7, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 6, + 7, + 3, + 6, + 5, + 6, + 6, + 6, + 7, + 8, + 8, + 8, + 8, + 568, + 9, + 9, + 26, + 34, + 63, + 33, + 34, + 42, + 56, + 55, + 24, + 512, + 71, + 24, + 34, + 33, + 34, + 37, + 42, + 559, + 56, + 57, + 26, + 33, + 34, + 34, + 37, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 56, + 57, + 24, + 514, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 24, + 34, + 33, + 33, + 34, + 68, + 42, + 57, + 24, + 293, + 212, + 570, + 573, + 9, + 2, + 2, + 9, + 26, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 23, + 9, + 34, + 37, + 42, + 56, + 24, + 62, + 26, + 24, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 63, + 34, + 42, + 56, + 55, + 24, + 9, + 26, + 34, + 33, + 37, + 42, + 52, + 57, + 24, + 34, + 33, + 34, + 42, + 56, + 57, + 26, + 34, + 34, + 56, + 57, + 62, + 24, + 34, + 34, + 37, + 56, + 55, + 9, + 62, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 160, + 162, + 162, + 161, + 9, + 34, + 34, + 34, + 36, + 42, + 56, + 55, + 29, + 33, + 34, + 34, + 37, + 42, + 56, + 24, + 33, + 34, + 33, + 56, + 57, + 9, + 24, + 34, + 34, + 33, + 42, + 55, + 24, + 24, + 34, + 34, + 37, + 52, + 57, + 24, + 62, + 34, + 42, + 34, + 9, + 52, + 56, + 56, + 24, + 34, + 57, + 61, + 61, + 61, + 24, + 24, + 42, + 26, + 26, + 65, + 34, + 56, + 24, + 34, + 333, + 9, + 34, + 42, + 56, + 24, + 34, + 63, + 56, + 55, + 62, + 34, + 37, + 56, + 34, + 37, + 56, + 57, + 24, + 34, + 34, + 60, + 62, + 24, + 42, + 55, + 9, + 34, + 34, + 63, + 42, + 55, + 26, + 56, + 24, + 34, + 363, + 9, + 62, + 63, + 68, + 24, + 55, + 9, + 9, + 34, + 56, + 55, + 34, + 37, + 55, + 52, + 61, + 9, + 34, + 24, + 57, + 57, + 34, + 34, + 9, + 34, + 62, + 9, + 37, + 9, + 34, + 42, + 62, + 34, + 42, + 62, + 68, + 42, + 62, + 52, + 24, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 169, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 140, + 140, + 169, + 169, + 140, + 140, + 139, + 142, + 142, + 142, + 2, + 3, + 3, + 3, + 3, + 3, + 7, + 7, + 7, + 6, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 574, + 515, + 185, + 227, + 235, + 222, + 575, + 237, + 9, + 9, + 9, + 24, + 34, + 34, + 34, + 37, + 56, + 58, + 58, + 62, + 9, + 34, + 34, + 34, + 34, + 33, + 42, + 56, + 57, + 62, + 2, + 63, + 34, + 34, + 68, + 333, + 56, + 24, + 63, + 34, + 42, + 56, + 55, + 24, + 62, + 24, + 24, + 34, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 24, + 63, + 34, + 34, + 68, + 42, + 56, + 57, + 24, + 34, + 34, + 63, + 34, + 42, + 56, + 357, + 26, + 33, + 34, + 34, + 37, + 42, + 42, + 60, + 62, + 9, + 62, + 34, + 34, + 33, + 68, + 42, + 56, + 55, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 24, + 26, + 24, + 24, + 167, + 576, + 160, + 162, + 124, + 24, + 62, + 34, + 33, + 63, + 68, + 42, + 56, + 57, + 512, + 24, + 34, + 34, + 34, + 42, + 56, + 62, + 2, + 24, + 24, + 34, + 34, + 37, + 26, + 56, + 24, + 2, + 34, + 34, + 34, + 37, + 42, + 9, + 34, + 42, + 37, + 333, + 55, + 34, + 56, + 34, + 42, + 62, + 37, + 33, + 34, + 9, + 42, + 24, + 34, + 37, + 55, + 33, + 34, + 42, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 24, + 34, + 34, + 37, + 42, + 56, + 24, + 26, + 34, + 34, + 9, + 26, + 62, + 34, + 34, + 578, + 57, + 34, + 33, + 34, + 56, + 57, + 24, + 34, + 63, + 42, + 56, + 34, + 34, + 34, + 37, + 42, + 55, + 9, + 31, + 9, + 24, + 34, + 363, + 37, + 42, + 56, + 62, + 26, + 62, + 33, + 34, + 34, + 42, + 56, + 62, + 34, + 34, + 34, + 42, + 56, + 62, + 2, + 63, + 42, + 56, + 57, + 34, + 34, + 34, + 29, + 42, + 55, + 24, + 34, + 37, + 42, + 57, + 34, + 37, + 62, + 34, + 34, + 9, + 34, + 42, + 55, + 62, + 24, + 34, + 34, + 55, + 26, + 33, + 63, + 63, + 42, + 363, + 24, + 26, + 24, + 26, + 33, + 33, + 56, + 55, + 62, + 65, + 34, + 42, + 52, + 24, + 62, + 34, + 56, + 57, + 62, + 34, + 34, + 42, + 55, + 37, + 56, + 24, + 34, + 9, + 63, + 42, + 62, + 56, + 357, + 24, + 34, + 363, + 42, + 551, + 34, + 34, + 34, + 42, + 24, + 34, + 34, + 42, + 62, + 34, + 34, + 42, + 56, + 61, + 61, + 61, + 61, + 61, + 61, + 24, + 34, + 34, + 42, + 33, + 34, + 42, + 34, + 34, + 62, + 24, + 9, + 34, + 37, + 23, + 34, + 34, + 34, + 42, + 55, + 24, + 62, + 62, + 24, + 62, + 34, + 34, + 63, + 56, + 9, + 579, + 24, + 24, + 65, + 34, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 34, + 34, + 34, + 37, + 56, + 55, + 26, + 34, + 34, + 33, + 34, + 42, + 42, + 57, + 24, + 26, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 34, + 34, + 34, + 37, + 56, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 140, + 140, + 140, + 139, + 169, + 140, + 140, + 139, + 139, + 140, + 140, + 140, + 139, + 139, + 139, + 140, + 169, + 142, + 142, + 142, + 142, + 3, + 3, + 5, + 5, + 5, + 5, + 5, + 6, + 7, + 7, + 5, + 7, + 6, + 4, + 6, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 4, + 4, + 5, + 5, + 170, + 6, + 4, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 7, + 3, + 6, + 5, + 6, + 6, + 4, + 5, + 2, + 5, + 6, + 6, + 6, + 7, + 4, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 5, + 6, + 5, + 5, + 4, + 6, + 4, + 4, + 6, + 6, + 5, + 4, + 5, + 2, + 6, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 4, + 6, + 6, + 6, + 5, + 6, + 5, + 5, + 7, + 6, + 5, + 5, + 6, + 7, + 6, + 6, + 5, + 6, + 6, + 5, + 4, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 7, + 5, + 3, + 6, + 4, + 6, + 6, + 6, + 5, + 5, + 7, + 5, + 6, + 5, + 4, + 6, + 6, + 5, + 5, + 5, + 4, + 7, + 6, + 4, + 6, + 6, + 8, + 171, + 8, + 8, + 9, + 580, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 65, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 60, + 24, + 62, + 26, + 24, + 24, + 26, + 33, + 63, + 33, + 37, + 42, + 56, + 55, + 24, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 82, + 582, + 92, + 9, + 2, + 9, + 9, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 62, + 34, + 33, + 34, + 34, + 36, + 42, + 55, + 62, + 26, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 22, + 24, + 34, + 34, + 33, + 42, + 42, + 363, + 24, + 583, + 112, + 9, + 2, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 55, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 363, + 57, + 26, + 33, + 33, + 63, + 33, + 42, + 42, + 527, + 62, + 357, + 24, + 33, + 34, + 34, + 68, + 56, + 55, + 24, + 22, + 24, + 34, + 33, + 37, + 42, + 56, + 62, + 26, + 24, + 34, + 34, + 34, + 24, + 42, + 56, + 55, + 9, + 24, + 33, + 34, + 34, + 36, + 42, + 56, + 55, + 24, + 26, + 34, + 34, + 34, + 33, + 24, + 42, + 56, + 57, + 24, + 9, + 24, + 24, + 34, + 34, + 34, + 36, + 42, + 363, + 24, + 65, + 62, + 24, + 34, + 33, + 34, + 68, + 42, + 56, + 55, + 26, + 24, + 33, + 34, + 34, + 68, + 42, + 56, + 55, + 62, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 33, + 34, + 34, + 68, + 56, + 245, + 24, + 24, + 62, + 9, + 24, + 34, + 63, + 33, + 37, + 42, + 56, + 57, + 71, + 62, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 62, + 62, + 34, + 34, + 33, + 33, + 42, + 42, + 60, + 24, + 24, + 33, + 33, + 34, + 42, + 56, + 57, + 62, + 24, + 24, + 62, + 33, + 34, + 34, + 36, + 42, + 56, + 60, + 57, + 26, + 24, + 33, + 34, + 34, + 68, + 42, + 9, + 62, + 34, + 34, + 42, + 56, + 24, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 357, + 26, + 33, + 34, + 34, + 34, + 68, + 42, + 52, + 62, + 24, + 26, + 62, + 9, + 24, + 24, + 34, + 63, + 34, + 36, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 33, + 33, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 34, + 34, + 42, + 52, + 62, + 71, + 24, + 34, + 63, + 34, + 34, + 42, + 40, + 60, + 62, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 62, + 9, + 34, + 34, + 63, + 24, + 333, + 56, + 551, + 62, + 65, + 34, + 33, + 34, + 34, + 37, + 40, + 62, + 65, + 63, + 9, + 33, + 37, + 34, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 169, + 139, + 142, + 142, + 3, + 61, + 61, + 61, + 61, + 61, + 5, + 6, + 5, + 2, + 4, + 5, + 5, + 5, + 5, + 5, + 4, + 6, + 4, + 6, + 170, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 10, + 24, + 34, + 63, + 33, + 584, + 42, + 56, + 24, + 34, + 62, + 24, + 34, + 33, + 34, + 42, + 42, + 60, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 227, + 37, + 162, + 161, + 9, + 24, + 34, + 68, + 42, + 52, + 57, + 24, + 26, + 24, + 62, + 63, + 63, + 33, + 42, + 56, + 55, + 9, + 24, + 2, + 34, + 34, + 34, + 42, + 56, + 57, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 62, + 24, + 62, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 9, + 42, + 55, + 62, + 9, + 34, + 34, + 34, + 42, + 62, + 26, + 33, + 34, + 42, + 24, + 24, + 42, + 56, + 9, + 24, + 34, + 34, + 26, + 33, + 24, + 34, + 9, + 24, + 34, + 37, + 42, + 34, + 34, + 24, + 52, + 62, + 9, + 26, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 34, + 63, + 56, + 57, + 377, + 33, + 34, + 34, + 42, + 55, + 2, + 34, + 37, + 52, + 34, + 34, + 56, + 57, + 24, + 71, + 62, + 34, + 33, + 37, + 42, + 56, + 55, + 24, + 34, + 34, + 56, + 62, + 34, + 34, + 42, + 34, + 34, + 42, + 57, + 62, + 63, + 34, + 42, + 62, + 2, + 24, + 24, + 33, + 34, + 34, + 42, + 26, + 33, + 37, + 55, + 62, + 61, + 61, + 61, + 61, + 61, + 33, + 34, + 24, + 34, + 68, + 62, + 42, + 57, + 37, + 56, + 9, + 33, + 33, + 33, + 34, + 24, + 34, + 580, + 63, + 33, + 37, + 24, + 62, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 140, + 169, + 140, + 139, + 169, + 139, + 139, + 169, + 169, + 140, + 139, + 140, + 139, + 140, + 142, + 142, + 2, + 3, + 3, + 2, + 3, + 6, + 5, + 5, + 7, + 6, + 6, + 5, + 6, + 6, + 5, + 5, + 6, + 5, + 6, + 6, + 5, + 2, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 4, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 7, + 6, + 3, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 4, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 7, + 5, + 7, + 5, + 6, + 6, + 6, + 7, + 6, + 6, + 2, + 3, + 6, + 170, + 5, + 5, + 6, + 5, + 7, + 6, + 5, + 6, + 6, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 7, + 6, + 5, + 6, + 7, + 3, + 6, + 4, + 7, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 6, + 5, + 6, + 7, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 7, + 6, + 6, + 7, + 6, + 6, + 5, + 8, + 171, + 171, + 355, + 9, + 377, + 62, + 34, + 34, + 33, + 390, + 42, + 56, + 57, + 24, + 26, + 24, + 34, + 34, + 34, + 42, + 56, + 2, + 71, + 62, + 24, + 71, + 34, + 34, + 34, + 33, + 37, + 42, + 56, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 9, + 9, + 24, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 31, + 26, + 24, + 2, + 34, + 34, + 34, + 42, + 56, + 55, + 9, + 33, + 34, + 34, + 37, + 42, + 60, + 24, + 24, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 9, + 235, + 227, + 587, + 221, + 226, + 304, + 26, + 62, + 34, + 34, + 34, + 63, + 42, + 56, + 57, + 62, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 62, + 24, + 63, + 34, + 34, + 68, + 42, + 56, + 55, + 24, + 24, + 62, + 33, + 34, + 34, + 42, + 56, + 55, + 24, + 65, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 62, + 26, + 24, + 9, + 24, + 34, + 33, + 34, + 24, + 42, + 56, + 55, + 24, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 33, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 52, + 62, + 24, + 24, + 34, + 34, + 63, + 37, + 42, + 56, + 57, + 2, + 24, + 34, + 34, + 42, + 56, + 245, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 62, + 34, + 34, + 33, + 63, + 42, + 56, + 57, + 26, + 34, + 63, + 63, + 37, + 42, + 56, + 55, + 24, + 9, + 24, + 24, + 2, + 62, + 33, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 34, + 33, + 33, + 42, + 56, + 60, + 588, + 24, + 24, + 34, + 37, + 42, + 56, + 57, + 26, + 34, + 34, + 34, + 33, + 42, + 56, + 55, + 24, + 24, + 124, + 24, + 34, + 34, + 33, + 36, + 42, + 245, + 24, + 24, + 34, + 33, + 34, + 37, + 42, + 52, + 62, + 62, + 62, + 26, + 24, + 24, + 34, + 34, + 63, + 34, + 42, + 42, + 56, + 55, + 26, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 9, + 62, + 24, + 33, + 33, + 33, + 42, + 42, + 55, + 62, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 24, + 24, + 24, + 62, + 34, + 34, + 34, + 34, + 68, + 42, + 56, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 52, + 62, + 589, + 24, + 34, + 34, + 63, + 37, + 42, + 56, + 55, + 24, + 71, + 62, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 65, + 34, + 34, + 33, + 34, + 42, + 52, + 62, + 33, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 24, + 34, + 34, + 37, + 590, + 56, + 24, + 22, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 65, + 24, + 33, + 33, + 34, + 42, + 56, + 55, + 31, + 26, + 34, + 34, + 63, + 34, + 42, + 56, + 245, + 57, + 24, + 24, + 24, + 62, + 34, + 34, + 34, + 68, + 42, + 56, + 62, + 9, + 26, + 62, + 33, + 63, + 34, + 42, + 56, + 55, + 24, + 24, + 63, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 26, + 24, + 62, + 63, + 34, + 34, + 42, + 56, + 57, + 105, + 9, + 26, + 24, + 33, + 34, + 37, + 42, + 60, + 24, + 26, + 62, + 34, + 34, + 63, + 68, + 42, + 52, + 24, + 9, + 24, + 9, + 9, + 24, + 61, + 34, + 34, + 37, + 42, + 2, + 24, + 26, + 24, + 34, + 34, + 34, + 24, + 29, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 591, + 22, + 62, + 62, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 26, + 24, + 34, + 34, + 34, + 68, + 42, + 363, + 62, + 62, + 26, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 357, + 62, + 24, + 34, + 63, + 33, + 68, + 42, + 56, + 62, + 24, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 22, + 2, + 24, + 63, + 34, + 33, + 37, + 42, + 56, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 2, + 62, + 24, + 63, + 34, + 34, + 34, + 42, + 243, + 55, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 24, + 24, + 24, + 62, + 34, + 33, + 34, + 42, + 42, + 56, + 57, + 24, + 24, + 63, + 34, + 34, + 33, + 37, + 42, + 56, + 55, + 357, + 24, + 63, + 34, + 34, + 68, + 42, + 56, + 57, + 24, + 24, + 24, + 24, + 9, + 62, + 31, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 62, + 33, + 34, + 63, + 34, + 42, + 56, + 55, + 24, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 24, + 65, + 24, + 34, + 34, + 63, + 37, + 42, + 56, + 24, + 62, + 26, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 71, + 34, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 24, + 26, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 57, + 24, + 9, + 24, + 33, + 34, + 42, + 56, + 55, + 62, + 2, + 26, + 34, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 62, + 9, + 65, + 65, + 65, + 26, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 62, + 26, + 71, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 62, + 24, + 24, + 33, + 34, + 33, + 37, + 42, + 56, + 57, + 31, + 62, + 63, + 34, + 34, + 34, + 42, + 42, + 363, + 24, + 389, + 26, + 24, + 34, + 33, + 34, + 42, + 56, + 57, + 9, + 9, + 33, + 34, + 9, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 142, + 3, + 3, + 4, + 6, + 6, + 5, + 7, + 7, + 2, + 5, + 7, + 5, + 9, + 37, + 42, + 42, + 56, + 406, + 24, + 65, + 34, + 34, + 24, + 24, + 61, + 61, + 593, + 594, + 9, + 9, + 595, + 2, + 377, + 24, + 24, + 26, + 62, + 34, + 63, + 34, + 42, + 56, + 55, + 24, + 9, + 414, + 315, + 323, + 326, + 326, + 105, + 9, + 9, + 9, + 62, + 33, + 34, + 34, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 527, + 24, + 9, + 9, + 9, + 42, + 56, + 62, + 9, + 26, + 24, + 34, + 63, + 37, + 42, + 55, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 2, + 34, + 63, + 34, + 37, + 42, + 42, + 24, + 9, + 34, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 62, + 24, + 34, + 63, + 33, + 37, + 42, + 56, + 57, + 9, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 62, + 9, + 62, + 62, + 34, + 33, + 34, + 42, + 42, + 55, + 24, + 9, + 24, + 34, + 33, + 42, + 42, + 245, + 57, + 24, + 26, + 24, + 34, + 33, + 33, + 37, + 42, + 363, + 57, + 26, + 33, + 34, + 34, + 34, + 37, + 56, + 245, + 62, + 313, + 24, + 62, + 34, + 34, + 33, + 68, + 42, + 56, + 57, + 533, + 2, + 61, + 596, + 598, + 607, + 22, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 31, + 24, + 24, + 332, + 23, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 26, + 34, + 24, + 63, + 37, + 42, + 56, + 57, + 62, + 24, + 608, + 426, + 427, + 428, + 611, + 613, + 616, + 619, + 619, + 621, + 621, + 633, + 637, + 640, + 643, + 9, + 9, + 9, + 71, + 9, + 113, + 2, + 9, + 62, + 33, + 33, + 34, + 42, + 40, + 55, + 62, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 140, + 142, + 142, + 3, + 3, + 3, + 3, + 5, + 6, + 6, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 5, + 5, + 7, + 7, + 6, + 7, + 6, + 5, + 6, + 6, + 5, + 5, + 5, + 5, + 4, + 5, + 6, + 7, + 6, + 5, + 5, + 6, + 170, + 7, + 6, + 5, + 5, + 6, + 6, + 7, + 6, + 4, + 6, + 6, + 6, + 6, + 7, + 6, + 7, + 7, + 5, + 5, + 6, + 6, + 5, + 7, + 6, + 5, + 7, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 3, + 6, + 6, + 5, + 4, + 7, + 5, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 5, + 6, + 5, + 5, + 4, + 5, + 5, + 6, + 6, + 7, + 6, + 5, + 6, + 5, + 7, + 5, + 7, + 5, + 7, + 5, + 6, + 5, + 7, + 7, + 7, + 5, + 6, + 6, + 2, + 7, + 7, + 7, + 5, + 6, + 9, + 644, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 2, + 645, + 392, + 654, + 9, + 135, + 3, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 42, + 56, + 55, + 62, + 657, + 9, + 26, + 24, + 9, + 9, + 62, + 660, + 160, + 162, + 9, + 26, + 33, + 34, + 34, + 34, + 42, + 56, + 245, + 24, + 9, + 26, + 24, + 34, + 34, + 63, + 37, + 42, + 55, + 62, + 34, + 34, + 33, + 63, + 42, + 245, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 24, + 24, + 34, + 55, + 33, + 9, + 2, + 34, + 26, + 23, + 533, + 9, + 34, + 42, + 56, + 62, + 52, + 425, + 425, + 427, + 427, + 427, + 427, + 669, + 674, + 9, + 9, + 2, + 34, + 34, + 33, + 42, + 56, + 55, + 9, + 52, + 62, + 62, + 24, + 62, + 34, + 37, + 56, + 24, + 471, + 353, + 34, + 34, + 34, + 34, + 42, + 56, + 24, + 62, + 24, + 34, + 34, + 33, + 68, + 42, + 55, + 9, + 34, + 33, + 34, + 34, + 34, + 34, + 34, + 37, + 42, + 52, + 24, + 327, + 24, + 33, + 42, + 56, + 55, + 24, + 24, + 62, + 579, + 34, + 33, + 37, + 42, + 56, + 57, + 62, + 34, + 33, + 33, + 33, + 42, + 56, + 60, + 62, + 9, + 24, + 24, + 63, + 34, + 37, + 42, + 56, + 57, + 62, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 2, + 24, + 34, + 34, + 42, + 56, + 24, + 19, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 414, + 26, + 34, + 34, + 34, + 42, + 42, + 55, + 24, + 33, + 33, + 34, + 34, + 42, + 56, + 2, + 24, + 24, + 34, + 34, + 33, + 42, + 56, + 363, + 2, + 71, + 62, + 34, + 24, + 34, + 333, + 42, + 55, + 24, + 24, + 9, + 33, + 33, + 33, + 42, + 56, + 57, + 313, + 71, + 34, + 34, + 33, + 397, + 56, + 55, + 24, + 24, + 26, + 34, + 33, + 34, + 68, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 34, + 63, + 37, + 42, + 56, + 57, + 62, + 9, + 24, + 34, + 34, + 34, + 38, + 56, + 57, + 24, + 63, + 34, + 34, + 42, + 42, + 55, + 2, + 34, + 33, + 33, + 34, + 37, + 56, + 55, + 24, + 2, + 26, + 24, + 33, + 34, + 33, + 37, + 42, + 55, + 2, + 62, + 33, + 63, + 34, + 68, + 42, + 55, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 531, + 71, + 63, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 9, + 254, + 9, + 26, + 24, + 34, + 33, + 34, + 42, + 26, + 34, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 9, + 71, + 62, + 9, + 33, + 34, + 34, + 584, + 42, + 56, + 55, + 62, + 24, + 24, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 24, + 71, + 33, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 589, + 26, + 24, + 34, + 34, + 33, + 37, + 56, + 55, + 24, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 9, + 62, + 24, + 63, + 34, + 34, + 34, + 42, + 24, + 62, + 24, + 34, + 63, + 34, + 37, + 42, + 56, + 24, + 24, + 24, + 34, + 34, + 34, + 42, + 42, + 55, + 62, + 9, + 24, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 9, + 33, + 37, + 42, + 26, + 24, + 34, + 34, + 68, + 55, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 9, + 23, + 24, + 34, + 33, + 34, + 37, + 42, + 24, + 62, + 24, + 34, + 63, + 33, + 24, + 24, + 34, + 34, + 37, + 42, + 363, + 2, + 62, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 2, + 34, + 34, + 24, + 377, + 62, + 34, + 34, + 42, + 56, + 57, + 313, + 26, + 24, + 34, + 34, + 42, + 56, + 62, + 63, + 9, + 24, + 62, + 9, + 33, + 34, + 42, + 42, + 60, + 24, + 9, + 34, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 9, + 24, + 34, + 34, + 34, + 68, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 24, + 33, + 34, + 33, + 42, + 44, + 55, + 57, + 24, + 26, + 62, + 34, + 34, + 34, + 34, + 34, + 42, + 42, + 363, + 57, + 580, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 26, + 62, + 9, + 34, + 34, + 33, + 34, + 42, + 55, + 24, + 24, + 26, + 24, + 34, + 37, + 56, + 60, + 24, + 9, + 62, + 63, + 34, + 34, + 333, + 56, + 57, + 24, + 2, + 62, + 34, + 33, + 33, + 42, + 56, + 57, + 24, + 9, + 24, + 33, + 34, + 34, + 42, + 56, + 55, + 62, + 9, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 363, + 62, + 676, + 679, + 679, + 678, + 679, + 678, + 678, + 680, + 681, + 685, + 467, + 693, + 680, + 466, + 695, + 699, + 703, + 707, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 169, + 169, + 139, + 139, + 169, + 139, + 169, + 139, + 139, + 169, + 139, + 169, + 169, + 140, + 139, + 139, + 141, + 140, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 5, + 6, + 5, + 2, + 5, + 6, + 6, + 4, + 6, + 6, + 7, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 6, + 4, + 5, + 6, + 5, + 5, + 4, + 5, + 6, + 7, + 5, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 5, + 5, + 5, + 6, + 6, + 5, + 5, + 3, + 5, + 5, + 5, + 2, + 6, + 5, + 5, + 5, + 7, + 5, + 7, + 6, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 6, + 4, + 6, + 5, + 170, + 6, + 6, + 5, + 5, + 2, + 6, + 7, + 6, + 7, + 5, + 4, + 6, + 5, + 3, + 5, + 6, + 4, + 5, + 7, + 6, + 7, + 4, + 6, + 3, + 4, + 6, + 6, + 7, + 5, + 6, + 6, + 7, + 5, + 7, + 5, + 6, + 6, + 6, + 6, + 6, + 5, + 4, + 5, + 5, + 7, + 5, + 6, + 5, + 5, + 170, + 6, + 6, + 8, + 8, + 8, + 8, + 8, + 2, + 9, + 26, + 24, + 34, + 33, + 34, + 34, + 37, + 42, + 56, + 57, + 414, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 81, + 708, + 2, + 9, + 2, + 24, + 31, + 34, + 34, + 63, + 42, + 56, + 55, + 24, + 24, + 34, + 42, + 56, + 55, + 9, + 26, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 26, + 71, + 34, + 34, + 34, + 37, + 42, + 55, + 24, + 9, + 61, + 34, + 34, + 34, + 34, + 42, + 55, + 31, + 9, + 62, + 34, + 34, + 34, + 37, + 42, + 52, + 57, + 62, + 2, + 24, + 63, + 34, + 63, + 42, + 42, + 55, + 62, + 26, + 62, + 63, + 34, + 42, + 56, + 55, + 9, + 62, + 34, + 34, + 37, + 56, + 55, + 62, + 24, + 33, + 34, + 34, + 34, + 42, + 42, + 55, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 24, + 9, + 62, + 34, + 42, + 56, + 57, + 9, + 42, + 57, + 9, + 26, + 63, + 34, + 34, + 42, + 42, + 24, + 63, + 33, + 34, + 37, + 42, + 60, + 313, + 65, + 24, + 24, + 34, + 33, + 34, + 37, + 56, + 57, + 9, + 24, + 34, + 63, + 34, + 42, + 56, + 55, + 62, + 9, + 24, + 34, + 33, + 34, + 42, + 42, + 56, + 57, + 2, + 26, + 34, + 34, + 34, + 42, + 60, + 24, + 33, + 63, + 33, + 37, + 42, + 56, + 9, + 113, + 711, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 516, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 3, + 5, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 6, + 5, + 5, + 6, + 6, + 5, + 3, + 5, + 7, + 6, + 6, + 5, + 6, + 6, + 7, + 2, + 5, + 4, + 5, + 5, + 7, + 8, + 171, + 171, + 8, + 568, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 716, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 33, + 9, + 24, + 9, + 37, + 56, + 9, + 9, + 9, + 26, + 62, + 63, + 33, + 56, + 55, + 9, + 33, + 34, + 68, + 56, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 42, + 9, + 33, + 56, + 9, + 23, + 65, + 34, + 34, + 42, + 56, + 9, + 34, + 33, + 34, + 42, + 56, + 55, + 24, + 34, + 63, + 42, + 55, + 9, + 34, + 42, + 56, + 34, + 37, + 24, + 9, + 9, + 42, + 24, + 26, + 24, + 24, + 42, + 56, + 57, + 24, + 34, + 42, + 56, + 9, + 24, + 9, + 34, + 9, + 37, + 24, + 24, + 34, + 34, + 42, + 60, + 42, + 55, + 62, + 34, + 34, + 37, + 56, + 55, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 26, + 34, + 34, + 63, + 42, + 9, + 68, + 9, + 9, + 34, + 397, + 56, + 9, + 42, + 55, + 9, + 9, + 34, + 34, + 33, + 42, + 56, + 57, + 9, + 33, + 37, + 42, + 52, + 24, + 9, + 24, + 34, + 37, + 24, + 9, + 62, + 24, + 34, + 37, + 56, + 55, + 9, + 33, + 34, + 63, + 42, + 56, + 9, + 26, + 34, + 33, + 34, + 34, + 56, + 24, + 26, + 34, + 34, + 34, + 55, + 9, + 24, + 33, + 34, + 37, + 42, + 55, + 9, + 62, + 62, + 24, + 34, + 34, + 42, + 56, + 24, + 62, + 26, + 24, + 34, + 34, + 24, + 42, + 363, + 57, + 24, + 33, + 34, + 71, + 34, + 37, + 56, + 23, + 24, + 24, + 33, + 34, + 36, + 42, + 52, + 2, + 9, + 57, + 23, + 9, + 34, + 33, + 34, + 55, + 24, + 24, + 26, + 34, + 34, + 34, + 24, + 56, + 55, + 62, + 26, + 24, + 33, + 34, + 34, + 37, + 42, + 60, + 24, + 65, + 24, + 34, + 33, + 37, + 37, + 56, + 55, + 62, + 34, + 42, + 56, + 55, + 24, + 718, + 722, + 730, + 26, + 33, + 33, + 34, + 42, + 55, + 9, + 62, + 63, + 34, + 42, + 56, + 55, + 9, + 24, + 742, + 33, + 34, + 55, + 34, + 34, + 37, + 42, + 56, + 24, + 9, + 26, + 34, + 33, + 63, + 34, + 42, + 56, + 55, + 62, + 24, + 62, + 34, + 34, + 63, + 333, + 56, + 363, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 26, + 62, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 62, + 62, + 33, + 34, + 34, + 34, + 42, + 56, + 245, + 24, + 22, + 62, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 26, + 62, + 24, + 24, + 34, + 34, + 24, + 37, + 42, + 245, + 24, + 24, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 55, + 24, + 2, + 62, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 24, + 9, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 55, + 313, + 24, + 24, + 34, + 34, + 34, + 36, + 42, + 56, + 57, + 9, + 71, + 24, + 34, + 34, + 34, + 34, + 42, + 42, + 56, + 57, + 26, + 62, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 167, + 24, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 363, + 24, + 24, + 123, + 24, + 34, + 33, + 34, + 36, + 42, + 56, + 57, + 62, + 9, + 62, + 34, + 34, + 34, + 37, + 56, + 55, + 24, + 26, + 33, + 34, + 34, + 68, + 42, + 56, + 57, + 9, + 26, + 34, + 63, + 34, + 33, + 42, + 743, + 55, + 24, + 62, + 26, + 34, + 34, + 34, + 42, + 56, + 57, + 62, + 34, + 34, + 34, + 42, + 42, + 55, + 26, + 24, + 34, + 63, + 34, + 37, + 42, + 245, + 62, + 26, + 34, + 63, + 33, + 68, + 42, + 55, + 62, + 26, + 63, + 37, + 333, + 55, + 24, + 24, + 33, + 34, + 33, + 68, + 42, + 56, + 9, + 2, + 62, + 34, + 33, + 24, + 333, + 56, + 57, + 9, + 62, + 34, + 34, + 33, + 37, + 42, + 55, + 349, + 9, + 112, + 232, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 574, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 9, + 139, + 140, + 139, + 139, + 139, + 169, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 141, + 139, + 139, + 139, + 139, + 140, + 139, + 139, + 139, + 169, + 140, + 139, + 139, + 169, + 139, + 142, + 142, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 3, + 6, + 4, + 5, + 6, + 5, + 5, + 7, + 7, + 5, + 6, + 5, + 5, + 7, + 4, + 6, + 6, + 5, + 6, + 5, + 7, + 5, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 6, + 7, + 6, + 5, + 6, + 5, + 6, + 5, + 4, + 5, + 6, + 5, + 5, + 6, + 6, + 6, + 6, + 7, + 6, + 5, + 6, + 3, + 5, + 5, + 5, + 6, + 5, + 6, + 6, + 5, + 7, + 6, + 7, + 7, + 5, + 6, + 6, + 6, + 6, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 6, + 4, + 5, + 6, + 4, + 6, + 6, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 7, + 6, + 5, + 5, + 5, + 2, + 6, + 5, + 3, + 7, + 5, + 5, + 6, + 6, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 6, + 6, + 7, + 6, + 2, + 6, + 6, + 6, + 6, + 3, + 5, + 4, + 5, + 6, + 6, + 6, + 5, + 6, + 7, + 5, + 6, + 6, + 5, + 8, + 8, + 171, + 354, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 746, + 518, + 227, + 191, + 747, + 226, + 748, + 9, + 471, + 159, + 162, + 753, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 24, + 24, + 34, + 34, + 9, + 9, + 333, + 57, + 9, + 9, + 33, + 60, + 9, + 9, + 9, + 34, + 34, + 9, + 9, + 33, + 34, + 56, + 57, + 62, + 34, + 34, + 42, + 55, + 9, + 34, + 34, + 37, + 9, + 62, + 63, + 24, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 24, + 34, + 34, + 55, + 9, + 9, + 34, + 333, + 55, + 62, + 9, + 34, + 42, + 24, + 34, + 57, + 9, + 9, + 26, + 24, + 26, + 34, + 34, + 245, + 9, + 26, + 34, + 34, + 42, + 57, + 26, + 24, + 37, + 42, + 56, + 62, + 24, + 24, + 62, + 2, + 62, + 24, + 37, + 24, + 62, + 33, + 40, + 57, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 62, + 2, + 24, + 34, + 37, + 56, + 55, + 9, + 34, + 37, + 55, + 9, + 33, + 34, + 42, + 55, + 62, + 62, + 62, + 34, + 33, + 37, + 42, + 60, + 9, + 62, + 34, + 34, + 42, + 56, + 9, + 34, + 33, + 37, + 42, + 56, + 26, + 34, + 34, + 34, + 42, + 60, + 62, + 62, + 34, + 34, + 34, + 37, + 42, + 60, + 24, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 26, + 62, + 9, + 33, + 34, + 34, + 9, + 24, + 34, + 33, + 55, + 24, + 9, + 24, + 34, + 34, + 34, + 333, + 56, + 62, + 26, + 23, + 34, + 34, + 37, + 42, + 55, + 62, + 24, + 34, + 34, + 34, + 42, + 55, + 24, + 62, + 34, + 34, + 37, + 42, + 52, + 62, + 62, + 34, + 34, + 34, + 37, + 56, + 62, + 9, + 24, + 34, + 56, + 24, + 9, + 34, + 34, + 37, + 42, + 56, + 9, + 62, + 63, + 34, + 34, + 42, + 42, + 57, + 24, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 9, + 62, + 34, + 33, + 42, + 56, + 24, + 26, + 62, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 24, + 62, + 34, + 34, + 37, + 42, + 42, + 52, + 24, + 24, + 9, + 26, + 34, + 33, + 34, + 37, + 525, + 55, + 24, + 26, + 24, + 33, + 34, + 34, + 42, + 56, + 55, + 62, + 65, + 62, + 34, + 34, + 34, + 34, + 37, + 42, + 60, + 31, + 26, + 62, + 63, + 34, + 34, + 37, + 42, + 56, + 57, + 757, + 24, + 24, + 34, + 34, + 34, + 34, + 36, + 42, + 56, + 57, + 9, + 24, + 62, + 34, + 34, + 63, + 37, + 42, + 56, + 57, + 26, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 26, + 34, + 34, + 33, + 34, + 42, + 56, + 55, + 62, + 62, + 24, + 34, + 34, + 34, + 24, + 42, + 55, + 24, + 24, + 26, + 33, + 34, + 34, + 33, + 37, + 42, + 55, + 24, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 24, + 62, + 34, + 63, + 34, + 37, + 42, + 56, + 57, + 9, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 2, + 71, + 24, + 34, + 34, + 34, + 63, + 34, + 37, + 42, + 62, + 9, + 24, + 34, + 33, + 33, + 40, + 56, + 55, + 62, + 9, + 62, + 34, + 34, + 34, + 34, + 42, + 42, + 55, + 24, + 65, + 34, + 33, + 34, + 68, + 42, + 56, + 55, + 24, + 26, + 62, + 34, + 63, + 34, + 42, + 56, + 55, + 758, + 62, + 24, + 34, + 34, + 34, + 390, + 42, + 52, + 24, + 26, + 2, + 34, + 34, + 34, + 34, + 42, + 42, + 52, + 62, + 9, + 62, + 9, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 26, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 62, + 9, + 34, + 63, + 34, + 34, + 33, + 42, + 56, + 57, + 24, + 24, + 71, + 34, + 63, + 33, + 37, + 45, + 57, + 62, + 33, + 34, + 42, + 56, + 57, + 9, + 551, + 34, + 34, + 33, + 34, + 42, + 56, + 57, + 9, + 62, + 34, + 34, + 34, + 37, + 42, + 245, + 62, + 26, + 33, + 63, + 34, + 34, + 42, + 56, + 57, + 62, + 26, + 33, + 34, + 34, + 36, + 42, + 60, + 9, + 508, + 24, + 24, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 140, + 140, + 139, + 139, + 139, + 141, + 141, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 139, + 169, + 140, + 140, + 140, + 140, + 139, + 139, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 5, + 6, + 4, + 7, + 5, + 6, + 6, + 5, + 7, + 6, + 7, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 170, + 6, + 6, + 5, + 5, + 2, + 6, + 5, + 5, + 7, + 5, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 7, + 6, + 6, + 6, + 7, + 6, + 6, + 5, + 7, + 6, + 4, + 6, + 6, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 4, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 4, + 7, + 5, + 2, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 5, + 6, + 6, + 5, + 5, + 4, + 5, + 5, + 6, + 7, + 5, + 5, + 7, + 5, + 6, + 5, + 6, + 5, + 3, + 7, + 5, + 5, + 6, + 6, + 6, + 6, + 5, + 6, + 7, + 3, + 5, + 6, + 5, + 5, + 6, + 5, + 7, + 6, + 5, + 5, + 5, + 5, + 5, + 7, + 6, + 4, + 4, + 8, + 8, + 8, + 8, + 8, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 382, + 524, + 147, + 160, + 162, + 162, + 415, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 26, + 34, + 42, + 55, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 71, + 9, + 9, + 24, + 34, + 37, + 56, + 57, + 26, + 33, + 52, + 24, + 33, + 42, + 9, + 34, + 37, + 57, + 57, + 9, + 9, + 34, + 9, + 9, + 9, + 9, + 9, + 34, + 33, + 63, + 42, + 56, + 9, + 9, + 9, + 34, + 63, + 34, + 37, + 60, + 24, + 24, + 34, + 63, + 42, + 363, + 9, + 24, + 33, + 34, + 34, + 56, + 57, + 24, + 9, + 33, + 34, + 63, + 42, + 56, + 62, + 62, + 26, + 34, + 34, + 33, + 42, + 56, + 24, + 9, + 34, + 34, + 37, + 42, + 57, + 9, + 63, + 34, + 34, + 42, + 56, + 57, + 9, + 24, + 63, + 63, + 42, + 57, + 9, + 24, + 34, + 34, + 34, + 56, + 55, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 24, + 2, + 63, + 34, + 37, + 56, + 57, + 26, + 24, + 26, + 63, + 33, + 37, + 42, + 55, + 24, + 22, + 33, + 34, + 33, + 42, + 55, + 24, + 62, + 63, + 33, + 42, + 56, + 57, + 62, + 62, + 33, + 33, + 33, + 42, + 52, + 62, + 24, + 63, + 34, + 61, + 42, + 56, + 24, + 24, + 34, + 37, + 42, + 55, + 9, + 24, + 34, + 33, + 34, + 42, + 56, + 55, + 29, + 24, + 26, + 63, + 34, + 34, + 42, + 56, + 57, + 24, + 9, + 24, + 34, + 34, + 34, + 42, + 56, + 24, + 26, + 63, + 33, + 37, + 57, + 9, + 34, + 34, + 37, + 42, + 56, + 62, + 24, + 24, + 34, + 33, + 37, + 56, + 57, + 759, + 24, + 63, + 34, + 34, + 42, + 56, + 2, + 24, + 62, + 26, + 34, + 34, + 33, + 37, + 42, + 55, + 24, + 24, + 24, + 34, + 34, + 34, + 42, + 55, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 24, + 24, + 24, + 34, + 34, + 33, + 34, + 42, + 56, + 57, + 9, + 24, + 34, + 34, + 34, + 37, + 56, + 55, + 357, + 62, + 62, + 34, + 34, + 34, + 36, + 42, + 55, + 62, + 26, + 24, + 63, + 34, + 34, + 37, + 56, + 55, + 2, + 24, + 24, + 26, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 63, + 34, + 34, + 37, + 42, + 55, + 62, + 9, + 24, + 33, + 34, + 34, + 42, + 42, + 363, + 24, + 26, + 24, + 34, + 34, + 37, + 42, + 56, + 62, + 2, + 24, + 34, + 34, + 34, + 37, + 56, + 57, + 2, + 62, + 34, + 34, + 63, + 34, + 42, + 56, + 57, + 62, + 24, + 62, + 34, + 33, + 34, + 37, + 56, + 55, + 9, + 62, + 24, + 26, + 63, + 63, + 34, + 37, + 42, + 56, + 57, + 24, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 62, + 9, + 24, + 33, + 33, + 34, + 42, + 42, + 52, + 57, + 24, + 62, + 63, + 34, + 33, + 37, + 42, + 56, + 62, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 57, + 26, + 24, + 34, + 34, + 33, + 37, + 42, + 52, + 594, + 26, + 62, + 34, + 34, + 34, + 34, + 42, + 56, + 62, + 24, + 24, + 34, + 33, + 42, + 56, + 43, + 62, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 71, + 34, + 33, + 34, + 34, + 42, + 56, + 55, + 24, + 2, + 24, + 34, + 34, + 34, + 24, + 42, + 56, + 24, + 26, + 62, + 34, + 33, + 34, + 33, + 333, + 56, + 55, + 24, + 62, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 57, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 29, + 62, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 56, + 31, + 24, + 26, + 34, + 33, + 34, + 37, + 42, + 56, + 57, + 24, + 26, + 24, + 34, + 63, + 34, + 37, + 42, + 363, + 62, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 62, + 34, + 33, + 34, + 37, + 42, + 56, + 55, + 62, + 71, + 62, + 34, + 63, + 34, + 37, + 42, + 56, + 55, + 471, + 197, + 762, + 226, + 237, + 9, + 24, + 24, + 33, + 63, + 33, + 34, + 42, + 56, + 62, + 26, + 24, + 34, + 33, + 2, + 37, + 333, + 55, + 2, + 24, + 34, + 33, + 34, + 37, + 56, + 55, + 24, + 24, + 34, + 33, + 34, + 42, + 56, + 57, + 62, + 24, + 33, + 34, + 37, + 42, + 60, + 24, + 34, + 34, + 34, + 63, + 42, + 56, + 57, + 26, + 62, + 33, + 34, + 34, + 37, + 56, + 52, + 62, + 26, + 62, + 34, + 2, + 34, + 42, + 56, + 57, + 10, + 34, + 34, + 63, + 42, + 42, + 55, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 332, + 111, + 233, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 61, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 169, + 139, + 139, + 140, + 139, + 139, + 169, + 139, + 169, + 140, + 139, + 140, + 139, + 139, + 139, + 139, + 139, + 139, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 3, + 5, + 6, + 6, + 4, + 6, + 6, + 7, + 7, + 7, + 7, + 6, + 5, + 7, + 4, + 7, + 4, + 6, + 6, + 6, + 5, + 5, + 6, + 7, + 5, + 7, + 5, + 4, + 6, + 7, + 5, + 5, + 6, + 6, + 5, + 5, + 5, + 6, + 7, + 7, + 6, + 6, + 6, + 5, + 6, + 6, + 7, + 6, + 4, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 7, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 6, + 7, + 5, + 5, + 5, + 5, + 6, + 4, + 7, + 5, + 7, + 5, + 6, + 6, + 6, + 6, + 6, + 6, + 5, + 5, + 6, + 5, + 2, + 5, + 4, + 5, + 6, + 7, + 5, + 5, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 7, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 4, + 4, + 5, + 2, + 5, + 4, + 5, + 6, + 6, + 5, + 7, + 5, + 4, + 8, + 8, + 171, + 8, + 8, + 2, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 764, + 213, + 765, + 9, + 9, + 9, + 147, + 160, + 162, + 165, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 26, + 9, + 9, + 9, + 34, + 33, + 57, + 9, + 9, + 9, + 9, + 9, + 37, + 9, + 34, + 34, + 42, + 9, + 24, + 63, + 33, + 56, + 62, + 9, + 33, + 63, + 42, + 9, + 134, + 9, + 34, + 34, + 42, + 57, + 26, + 34, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 62, + 34, + 34, + 34, + 68, + 42, + 57, + 9, + 2, + 34, + 33, + 52, + 24, + 24, + 34, + 34, + 34, + 42, + 363, + 57, + 26, + 62, + 9, + 34, + 34, + 33, + 42, + 56, + 62, + 9, + 24, + 34, + 34, + 42, + 56, + 55, + 24, + 26, + 24, + 63, + 34, + 37, + 42, + 56, + 57, + 24, + 62, + 34, + 33, + 63, + 42, + 52, + 24, + 26, + 24, + 34, + 34, + 37, + 42, + 60, + 24, + 24, + 24, + 34, + 34, + 42, + 56, + 57, + 22, + 62, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 26, + 24, + 34, + 34, + 34, + 34, + 42, + 56, + 57, + 24, + 24, + 34, + 33, + 33, + 37, + 42, + 56, + 24, + 357, + 2, + 34, + 34, + 34, + 42, + 56, + 57, + 9, + 24, + 24, + 34, + 33, + 34, + 37, + 56, + 55, + 24, + 26, + 24, + 33, + 33, + 33, + 42, + 56, + 55, + 26, + 62, + 34, + 34, + 34, + 55, + 57, + 9, + 71, + 62, + 24, + 34, + 33, + 33, + 42, + 56, + 55, + 24, + 26, + 34, + 34, + 33, + 34, + 42, + 9, + 9, + 62, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 24, + 62, + 33, + 34, + 34, + 42, + 56, + 55, + 407, + 26, + 24, + 26, + 63, + 34, + 34, + 42, + 56, + 62, + 24, + 9, + 34, + 63, + 34, + 37, + 42, + 56, + 57, + 62, + 34, + 34, + 34, + 9, + 24, + 63, + 34, + 33, + 37, + 42, + 52, + 57, + 62, + 42, + 56, + 57, + 512, + 26, + 62, + 34, + 33, + 34, + 37, + 42, + 55, + 61, + 61, + 9, + 24, + 9, + 9, + 63, + 34, + 33, + 34, + 42, + 56, + 57, + 9, + 26, + 24, + 34, + 34, + 34, + 37, + 42, + 245, + 9, + 24, + 24, + 26, + 34, + 33, + 33, + 42, + 56, + 55, + 24, + 24, + 24, + 33, + 33, + 34, + 37, + 42, + 55, + 24, + 26, + 24, + 34, + 34, + 42, + 56, + 55, + 62, + 9, + 24, + 34, + 34, + 34, + 37, + 56, + 24, + 9, + 24, + 34, + 37, + 60, + 24, + 63, + 34, + 34, + 42, + 56, + 9, + 34, + 33, + 34, + 37, + 42, + 24, + 9, + 62, + 34, + 34, + 42, + 52, + 9, + 62, + 34, + 34, + 34, + 42, + 56, + 9, + 24, + 26, + 34, + 34, + 34, + 37, + 56, + 363, + 24, + 9, + 42, + 55, + 24, + 26, + 34, + 42, + 56, + 24, + 24, + 63, + 34, + 37, + 56, + 57, + 62, + 62, + 34, + 33, + 34, + 34, + 42, + 56, + 55, + 9, + 24, + 34, + 34, + 34, + 37, + 42, + 363, + 9, + 62, + 24, + 34, + 34, + 42, + 363, + 2, + 62, + 24, + 24, + 63, + 34, + 34, + 42, + 56, + 57, + 62, + 2, + 31, + 34, + 34, + 34, + 42, + 42, + 55, + 24, + 24, + 62, + 34, + 34, + 63, + 37, + 42, + 55, + 24, + 26, + 24, + 34, + 34, + 68, + 42, + 56, + 62, + 26, + 24, + 34, + 34, + 33, + 42, + 56, + 55, + 31, + 26, + 24, + 34, + 34, + 24, + 42, + 56, + 55, + 2, + 24, + 34, + 34, + 34, + 37, + 42, + 55, + 9, + 24, + 34, + 34, + 34, + 68, + 42, + 55, + 62, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 2, + 26, + 62, + 34, + 63, + 34, + 42, + 42, + 55, + 62, + 26, + 24, + 34, + 34, + 34, + 56, + 62, + 9, + 62, + 34, + 34, + 34, + 68, + 42, + 56, + 24, + 26, + 24, + 34, + 34, + 34, + 42, + 56, + 24, + 22, + 34, + 34, + 34, + 42, + 56, + 24, + 34, + 34, + 34, + 42, + 56, + 60, + 22, + 24, + 34, + 33, + 34, + 37, + 42, + 52, + 9, + 24, + 34, + 34, + 34, + 68, + 42, + 56, + 62, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 768, + 113, + 167, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 770, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 140, + 139, + 169, + 139, + 169, + 139, + 169, + 169, + 139, + 169, + 140, + 169, + 139, + 139, + 142, + 142, + 142, + 142, + 3, + 3, + 3, + 3, + 3, + 3, + 6, + 5, + 5, + 7, + 5, + 5, + 2, + 5, + 7, + 6, + 6, + 5, + 5, + 4, + 6, + 5, + 5, + 6, + 5, + 5, + 7, + 5, + 5, + 5, + 5, + 5, + 5, + 6, + 2, + 7, + 6, + 6, + 2, + 5, + 5, + 5, + 6, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 6, + 5, + 5, + 6, + 2, + 5, + 7, + 5, + 4, + 5, + 6, + 5, + 6, + 6, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 6, + 5, + 5, + 7, + 6, + 6, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 4, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 6, + 5, + 6, + 7, + 5, + 7, + 7, + 4, + 5, + 7, + 4, + 5, + 7, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 5, + 5, + 3, + 5, + 4, + 5, + 6, + 6, + 5, + 6, + 5, + 5, + 6, + 6, + 2, + 3, + 4, + 6, + 5, + 5, + 3, + 6, + 6, + 6, + 5, + 7, + 6, + 5, + 5, + 6, + 6, + 3, + 5, + 6, + 5, + 5, + 8, + 8, + 8, + 8, + 9, + 9, + 185, + 235, + 206, + 226, + 9, + 9, + 9, + 9, + 9, + 160, + 162, + 162, + 773, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 24, + 9, + 9, + 33, + 34, + 37, + 743, + 9, + 24, + 9, + 9, + 33, + 42, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 65, + 26, + 62, + 34, + 33, + 37, + 42, + 55, + 9, + 62, + 33, + 34, + 34, + 42, + 55, + 9, + 34, + 33, + 68, + 42, + 57, + 9, + 33, + 34, + 333, + 57, + 24, + 34, + 24, + 37, + 55, + 26, + 24, + 33, + 34, + 42, + 62, + 24, + 34, + 34, + 42, + 9, + 62, + 34, + 42, + 56, + 57, + 24, + 9, + 34, + 33, + 68, + 56, + 24, + 24, + 71, + 34, + 33, + 34, + 37, + 52, + 62, + 34, + 63, + 34, + 56, + 55, + 62, + 24, + 34, + 42, + 56, + 62, + 125, + 34, + 34, + 63, + 60, + 9, + 24, + 34, + 34, + 37, + 42, + 62, + 644, + 24, + 33, + 63, + 37, + 56, + 24, + 9, + 24, + 34, + 34, + 42, + 60, + 57, + 26, + 34, + 37, + 42, + 55, + 9, + 34, + 42, + 56, + 24, + 9, + 33, + 55, + 62, + 9, + 34, + 34, + 42, + 60, + 2, + 24, + 63, + 56, + 57, + 34, + 33, + 42, + 55, + 9, + 24, + 34, + 34, + 40, + 10, + 24, + 34, + 34, + 55, + 9, + 24, + 34, + 34, + 9, + 26, + 62, + 34, + 33, + 37, + 57, + 9, + 62, + 34, + 2, + 56, + 57, + 62, + 9, + 33, + 34, + 42, + 55, + 24, + 9, + 55, + 61, + 61, + 61, + 61, + 61, + 9, + 34, + 34, + 42, + 24, + 62, + 34, + 34, + 42, + 56, + 24, + 34, + 42, + 57, + 34, + 56, + 512, + 62, + 34, + 34, + 42, + 56, + 62, + 33, + 34, + 42, + 56, + 9, + 26, + 34, + 42, + 56, + 24, + 9, + 24, + 37, + 42, + 60, + 2, + 33, + 42, + 57, + 9, + 55, + 9, + 37, + 56, + 9, + 24, + 24, + 34, + 24, + 42, + 363, + 9, + 62, + 34, + 33, + 34, + 42, + 56, + 57, + 24, + 24, + 34, + 34, + 34, + 42, + 56, + 55, + 26, + 62, + 26, + 34, + 34, + 37, + 42, + 55, + 62, + 26, + 34, + 34, + 37, + 56, + 167, + 24, + 34, + 63, + 37, + 42, + 57, + 24, + 26, + 24, + 34, + 33, + 37, + 42, + 56, + 62, + 2, + 24, + 33, + 34, + 34, + 42, + 56, + 62, + 26, + 24, + 34, + 34, + 34, + 42, + 56, + 57, + 2, + 71, + 24, + 34, + 34, + 34, + 42, + 56, + 60, + 9, + 24, + 9, + 34, + 34, + 63, + 37, + 42, + 57, + 2, + 26, + 34, + 34, + 34, + 42, + 363, + 24, + 62, + 9, + 33, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 9, + 34, + 34, + 34, + 34, + 42, + 56, + 55, + 24, + 9, + 71, + 34, + 34, + 33, + 24, + 42, + 56, + 62, + 26, + 62, + 33, + 34, + 34, + 42, + 56, + 57, + 9, + 26, + 24, + 34, + 34, + 33, + 42, + 56, + 24, + 2, + 24, + 34, + 34, + 33, + 37, + 42, + 56, + 57, + 125, + 24, + 63, + 34, + 33, + 36, + 42, + 56, + 57, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 23, + 62, + 34, + 34, + 33, + 34, + 68, + 42, + 55, + 313, + 24, + 62, + 9, + 34, + 34, + 34, + 33, + 42, + 56, + 57, + 24, + 24, + 24, + 34, + 34, + 34, + 9, + 9, + 34, + 31, + 33, + 42, + 56, + 55, + 62, + 9, + 10, + 9, + 9, + 9, + 9, + 26, + 34, + 34, + 33, + 42, + 775, + 57, + 62, + 65, + 62, + 34, + 34, + 34, + 37, + 42, + 55, + 62, + 24, + 34, + 34, + 34, + 33, + 42, + 42, + 56, + 62, + 9, + 42, + 776, + 24, + 62, + 34, + 34, + 34, + 42, + 9, + 71, + 62, + 34, + 34, + 37, + 42, + 52, + 24, + 2, + 9, + 9, + 9, + 580, + 9, + 235, + 197, + 297, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 138, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 135, + 139, + 139, + 139, + 139, + 139, + 169, + 139, + 139, + 140, + 139, + 140, + 140, + 169, + 139, + 139, + 139, + 169, + 2, + 142, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 142, + 142, + 3, + 3, + 6, + 5, + 5, + 6, + 4, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 5, + 5, + 5, + 6, + 5, + 7, + 7, + 5, + 5, + 5, + 6, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 5, + 5, + 4, + 7, + 5, + 7, + 5, + 7, + 7, + 6, + 5, + 6, + 6, + 5, + 6, + 6, + 6, + 6, + 5, + 5, + 5, + 6, + 5, + 4, + 6, + 5, + 6, + 7, + 5, + 6, + 5, + 5, + 5, + 7, + 5, + 6, + 5, + 5, + 4, + 7, + 5, + 6, + 5, + 5, + 6, + 2, + 7, + 6, + 5, + 5, + 5, + 5, + 6, + 6, + 7, + 6, + 7, + 6, + 6, + 7, + 5, + 6, + 6, + 7, + 5, + 6, + 7, + 6, + 7, + 5, + 6, + 5, + 6, + 5, + 6, + 6, + 6, + 3, + 5, + 5, + 6, + 4, + 7, + 7, + 6, + 6, + 5, + 6, + 7, + 6, + 7, + 5, + 6, + 6, + 6, + 5, + 5, + 5, + 4, + 5, + 6, + 8, + 8, + 171, + 355, + 9, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 61, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 389, + 9, + 564, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 471, + 2, + 235, + 222, + 226, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 777, + 778, + 147, + 571, + 306, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 787, + 2, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 2 + ], + "timeDeltas": [ + 578125, + 250, + 167, + 125, + 42, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 208, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 208, + 125, + 125, + 167, + 166, + 84, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 500, + 41, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 41, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 250, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 250, + 125, + 166, + 125, + 209, + 208, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 84, + 83, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 42, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 42, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 167, + 166, + 167, + 208, + 167, + 167, + 208, + 208, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 208, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 209, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 83, + 250, + 125, + 125, + 167, + 166, + 250, + 334, + 83, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 333, + 125, + 500, + 375, + 42, + 167, + 208, + 250, + 167, + 250, + 166, + 167, + 250, + 208, + 125, + 167, + 125, + 167, + 250, + 208, + 167, + 208, + 125, + 208, + 167, + 333, + 250, + 292, + 125, + 250, + 250, + 333, + 250, + 167, + 167, + 333, + 250, + 292, + 291, + 250, + 292, + 917, + 291, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 208, + 417, + 250, + 416, + 167, + 125, + 125, + 125, + 208, + 84, + 125, + 166, + 209, + 250, + 1375, + 166, + 167, + 875, + 167, + 375, + 83, + 250, + 83, + 209, + 250, + 208, + 208, + 209, + 208, + 1083, + 250, + 167, + 125, + 250, + 167, + 125, + 416, + 167, + 167, + 958, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 208, + 125, + 125, + 250, + 84, + 166, + 125, + 125, + 125, + 42, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 209, + 166, + 459, + 833, + 125, + 167, + 83, + 125, + 125, + 125, + 208, + 209, + 166, + 209, + 166, + 167, + 1833, + 167, + 125, + 167, + 166, + 292, + 167, + 166, + 209, + 250, + 125, + 333, + 167, + 583, + 250, + 208, + 1625, + 875, + 167, + 83, + 209, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 208, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 292, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 500, + 42, + 125, + 167, + 125, + 166, + 84, + 625, + 83, + 167, + 125, + 166, + 167, + 167, + 208, + 83, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 208, + 250, + 0, + 125, + 167, + 416, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 167, + 458, + 167, + 3250, + 3041, + 2625, + 1209, + 791, + 1042, + 1417, + 1041, + 1584, + 458, + 458, + 334, + 291, + 292, + 292, + 1541, + 584, + 541, + 250, + 334, + 125, + 375, + 458, + 250, + 250, + 458, + 167, + 208, + 167, + 125, + 375, + 208, + 167, + 583, + 292, + 208, + 209, + 375, + 166, + 1000, + 667, + 625, + 1000, + 833, + 375, + 209, + 166, + 2167, + 250, + 333, + 292, + 417, + 208, + 250, + 1000, + 167, + 250, + 250, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 250, + 166, + 8667, + 3083, + 4417, + 1042, + 833, + 125, + 167, + 7333, + 11000, + 3083, + 12834, + 791, + 4709, + 83, + 417, + 666, + 500, + 1542, + 4875, + 167, + 16041, + 2000, + 417, + 6125, + 167, + 8125, + 1458, + 542, + 500, + 166, + 292, + 125, + 417, + 125, + 416, + 584, + 291, + 334, + 291, + 459, + 666, + 5667, + 250, + 2875, + 47833, + 3500, + 3042, + 1667, + 250, + 666, + 1125, + 959, + 3250, + 1916, + 1375, + 250, + 18334, + 2333, + 16583, + 834, + 208, + 208, + 250, + 2125, + 167, + 125, + 1208, + 1292, + 1375, + 417, + 375, + 291, + 167, + 375, + 375, + 167, + 208, + 292, + 125, + 166, + 167, + 167, + 208, + 167, + 208, + 167, + 750, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 209, + 333, + 167, + 291, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 208, + 167, + 167, + 166, + 209, + 166, + 250, + 167, + 208, + 167, + 292, + 875, + 208, + 167, + 166, + 334, + 166, + 125, + 209, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 292, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 250, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 750, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 84, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 250, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 459, + 125, + 125, + 458, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 416, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 833, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 208, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 5458, + 208, + 125, + 167, + 2375, + 125, + 542, + 833, + 1208, + 625, + 167, + 2208, + 125, + 209, + 166, + 125, + 584, + 125, + 166, + 584, + 125, + 125, + 125, + 166, + 1625, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 208, + 208, + 917, + 1208, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 208, + 209, + 166, + 167, + 167, + 291, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 250, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 2542, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 334, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 209, + 250, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 208, + 167, + 250, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 208, + 125, + 125, + 167, + 500, + 166, + 250, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 125, + 166, + 209, + 166, + 167, + 1125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 1042, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 84, + 125, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 167, + 83, + 125, + 125, + 125, + 167, + 583, + 209, + 458, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 83, + 125, + 209, + 333, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 83, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 500, + 334, + 291, + 292, + 42, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 375, + 167, + 41, + 84, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 208, + 125, + 125, + 125, + 167, + 167, + 250, + 166, + 125, + 125, + 167, + 125, + 167, + 83, + 167, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 167, + 208, + 0, + 208, + 167, + 83, + 375, + 334, + 125, + 166, + 167, + 167, + 83, + 125, + 208, + 167, + 208, + 125, + 209, + 208, + 167, + 83, + 167, + 166, + 125, + 125, + 125, + 250, + 167, + 167, + 166, + 1084, + 333, + 125, + 167, + 125, + 125, + 125, + 166, + 209, + 208, + 167, + 125, + 166, + 917, + 167, + 166, + 125, + 250, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 250, + 167, + 167, + 83, + 250, + 167, + 208, + 125, + 167, + 250, + 750, + 708, + 208, + 209, + 250, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 167, + 166, + 167, + 125, + 250, + 125, + 167, + 250, + 125, + 208, + 167, + 125, + 166, + 125, + 209, + 83, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 209, + 208, + 208, + 167, + 125, + 167, + 125, + 166, + 334, + 0, + 1000, + 250, + 166, + 167, + 167, + 125, + 208, + 125, + 125, + 167, + 208, + 83, + 167, + 125, + 2083, + 167, + 125, + 167, + 125, + 291, + 0, + 209, + 291, + 167, + 1167, + 250, + 166, + 3334, + 708, + 167, + 208, + 125, + 167, + 208, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 250, + 1084, + 1291, + 834, + 750, + 208, + 667, + 833, + 250, + 250, + 375, + 333, + 250, + 209, + 250, + 375, + 250, + 500, + 333, + 417, + 583, + 250, + 333, + 792, + 292, + 541, + 334, + 333, + 250, + 167, + 1958, + 167, + 708, + 292, + 125, + 166, + 125, + 250, + 125, + 167, + 167, + 83, + 125, + 125, + 125, + 83, + 334, + 125, + 333, + 167, + 166, + 125, + 250, + 209, + 166, + 125, + 167, + 125, + 208, + 209, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 250, + 41, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 83, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 209, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 83, + 125, + 125, + 375, + 0, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 250, + 167, + 166, + 250, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 208, + 167, + 166, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 83, + 84, + 666, + 167, + 250, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 166, + 167, + 208, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 83, + 84, + 83, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 125, + 209, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 250, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 84, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 208, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 250, + 42, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 83, + 125, + 167, + 83, + 167, + 375, + 167, + 125, + 125, + 208, + 292, + 166, + 125, + 167, + 208, + 125, + 167, + 250, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 292, + 83, + 167, + 167, + 125, + 125, + 166, + 84, + 125, + 166, + 84, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 125, + 208, + 125, + 208, + 167, + 125, + 167, + 250, + 125, + 500, + 166, + 167, + 583, + 167, + 125, + 167, + 166, + 334, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 209, + 125, + 125, + 166, + 125, + 125, + 125, + 375, + 42, + 125, + 250, + 167, + 125, + 208, + 167, + 83, + 208, + 125, + 125, + 292, + 167, + 83, + 167, + 125, + 416, + 0, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 417, + 41, + 125, + 167, + 125, + 42, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 125, + 167, + 166, + 334, + 291, + 167, + 292, + 208, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 208, + 83, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 83, + 167, + 208, + 125, + 167, + 125, + 250, + 333, + 84, + 166, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 292, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 83, + 167, + 125, + 167, + 83, + 167, + 166, + 125, + 167, + 125, + 167, + 250, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 250, + 125, + 167, + 125, + 250, + 250, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 167, + 83, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 250, + 167, + 125, + 208, + 167, + 416, + 167, + 125, + 208, + 167, + 292, + 125, + 125, + 125, + 166, + 209, + 500, + 166, + 417, + 0, + 125, + 125, + 125, + 208, + 167, + 208, + 459, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 208, + 125, + 167, + 167, + 208, + 208, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 83, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 209, + 208, + 125, + 208, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 250, + 167, + 167, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 375, + 125, + 166, + 125, + 167, + 125, + 167, + 83, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 209, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 209, + 166, + 125, + 167, + 292, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 333, + 42, + 125, + 208, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 250, + 458, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 209, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 208, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 291, + 167, + 167, + 791, + 1042, + 292, + 1625, + 125, + 166, + 125, + 334, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 208, + 208, + 42, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 208, + 208, + 292, + 125, + 125, + 167, + 333, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 208, + 84, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 250, + 42, + 208, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 292, + 41, + 209, + 41, + 167, + 417, + 41, + 250, + 42, + 208, + 84, + 166, + 125, + 167, + 250, + 333, + 292, + 125, + 167, + 333, + 83, + 125, + 167, + 167, + 166, + 209, + 83, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 83, + 84, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 41, + 42, + 83, + 84, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 42, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 83, + 42, + 83, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 167, + 250, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 209, + 125, + 83, + 167, + 166, + 167, + 125, + 125, + 375, + 42, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 209, + 41, + 167, + 167, + 125, + 125, + 125, + 166, + 42, + 167, + 166, + 125, + 167, + 167, + 166, + 209, + 125, + 208, + 83, + 167, + 125, + 167, + 166, + 209, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 500, + 84, + 166, + 125, + 292, + 83, + 125, + 167, + 333, + 42, + 250, + 208, + 167, + 208, + 125, + 125, + 167, + 167, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 167, + 167, + 125, + 166, + 42, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 250, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 209, + 208, + 208, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 42, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 41, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 667, + 0, + 166, + 167, + 167, + 250, + 291, + 209, + 166, + 125, + 292, + 292, + 208, + 250, + 250, + 42, + 125, + 125, + 166, + 167, + 125, + 333, + 334, + 41, + 334, + 291, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 250, + 792, + 167, + 125, + 208, + 167, + 250, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 250, + 167, + 125, + 167, + 125, + 83, + 167, + 125, + 375, + 41, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 708, + 125, + 167, + 500, + 375, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 625, + 167, + 167, + 250, + 125, + 125, + 166, + 167, + 125, + 208, + 250, + 167, + 167, + 125, + 333, + 750, + 1333, + 4000, + 1917, + 1875, + 833, + 1500, + 667, + 125, + 667, + 750, + 375, + 666, + 500, + 1125, + 42, + 458, + 334, + 333, + 2125, + 1292, + 750, + 208, + 292, + 166, + 1000, + 292, + 208, + 334, + 333, + 542, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 583, + 250, + 208, + 125, + 125, + 250, + 167, + 125, + 292, + 125, + 166, + 125, + 167, + 208, + 250, + 292, + 208, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 291, + 334, + 208, + 375, + 167, + 125, + 125, + 125, + 250, + 166, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 375, + 125, + 125, + 208, + 167, + 125, + 167, + 166, + 250, + 167, + 167, + 333, + 125, + 125, + 167, + 125, + 166, + 1667, + 125, + 125, + 167, + 166, + 167, + 167, + 791, + 292, + 250, + 292, + 1291, + 1834, + 583, + 2917, + 2250, + 583, + 1208, + 1750, + 1334, + 2708, + 1542, + 125, + 291, + 2417, + 2542, + 458, + 167, + 166, + 167, + 208, + 375, + 1375, + 667, + 500, + 167, + 291, + 167, + 250, + 292, + 250, + 208, + 125, + 208, + 459, + 166, + 167, + 125, + 167, + 1000, + 208, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 250, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 166, + 875, + 834, + 250, + 291, + 417, + 417, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 250, + 292, + 125, + 208, + 125, + 125, + 125, + 167, + 41, + 167, + 125, + 125, + 125, + 208, + 375, + 209, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 167, + 375, + 125, + 208, + 167, + 208, + 167, + 167, + 208, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 209, + 250, + 125, + 166, + 750, + 1334, + 125, + 166, + 125, + 125, + 250, + 375, + 542, + 292, + 500, + 250, + 20750, + 7833, + 14125, + 167, + 18708, + 583, + 78584, + 41833, + 1292, + 8041, + 45834, + 9875, + 8958, + 5500, + 2625, + 3875, + 3333, + 7334, + 2291, + 3667, + 167, + 166, + 209, + 166, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 292, + 708, + 209, + 166, + 167, + 292, + 166, + 209, + 250, + 166, + 209, + 125, + 1208, + 1375, + 1458, + 667, + 125, + 583, + 167, + 583, + 500, + 250, + 125, + 125, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 333, + 167, + 250, + 125, + 167, + 166, + 250, + 167, + 125, + 167, + 375, + 166, + 125, + 250, + 125, + 375, + 125, + 125, + 125, + 167, + 167, + 291, + 1375, + 2334, + 333, + 125, + 167, + 166, + 125, + 1250, + 792, + 208, + 167, + 167, + 166, + 250, + 167, + 208, + 209, + 208, + 125, + 167, + 208, + 167, + 166, + 167, + 375, + 375, + 1083, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 250, + 166, + 167, + 167, + 166, + 167, + 1292, + 125, + 166, + 167, + 167, + 208, + 292, + 333, + 208, + 250, + 167, + 1167, + 125, + 125, + 166, + 125, + 542, + 125, + 167, + 125, + 166, + 125, + 459, + 208, + 125, + 125, + 458, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 541, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 750, + 208, + 167, + 208, + 125, + 208, + 209, + 125, + 166, + 375, + 42, + 250, + 458, + 209, + 208, + 125, + 167, + 583, + 167, + 375, + 458, + 42, + 291, + 209, + 166, + 84, + 208, + 583, + 84, + 250, + 166, + 209, + 250, + 208, + 250, + 125, + 250, + 125, + 167, + 208, + 208, + 167, + 125, + 208, + 125, + 167, + 167, + 625, + 333, + 250, + 167, + 125, + 458, + 333, + 167, + 250, + 458, + 125, + 250, + 125, + 459, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 334, + 958, + 167, + 125, + 166, + 167, + 1667, + 291, + 125, + 250, + 167, + 250, + 333, + 167, + 417, + 666, + 1084, + 2583, + 208, + 15584, + 125, + 125, + 208, + 208, + 1917, + 2875, + 2333, + 209, + 166, + 375, + 1084, + 1666, + 1084, + 4291, + 500, + 250, + 2584, + 7666, + 542, + 2500, + 5583, + 167, + 167, + 250, + 208, + 542, + 166, + 167, + 167, + 250, + 166, + 167, + 333, + 1250, + 250, + 250, + 125, + 250, + 167, + 250, + 292, + 375, + 291, + 250, + 459, + 416, + 209, + 208, + 250, + 167, + 125, + 166, + 167, + 208, + 250, + 167, + 167, + 250, + 208, + 167, + 333, + 3458, + 375, + 334, + 166, + 167, + 167, + 208, + 208, + 167, + 167, + 208, + 292, + 458, + 250, + 292, + 166, + 167, + 333, + 167, + 292, + 6708, + 167, + 125, + 250, + 375, + 166, + 292, + 167, + 291, + 417, + 167, + 250, + 250, + 375, + 708, + 1417, + 2750, + 21541, + 3834, + 1416, + 459, + 166, + 4292, + 4750, + 167, + 208, + 8000, + 500, + 500, + 208, + 209, + 125, + 2833, + 4292, + 5041, + 125, + 84, + 166, + 125, + 125, + 250, + 209, + 166, + 584, + 291, + 542, + 292, + 250, + 208, + 250, + 417, + 125, + 208, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 208, + 167, + 1792, + 166, + 209, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 292, + 166, + 792, + 667, + 125, + 291, + 167, + 125, + 125, + 375, + 125, + 167, + 125, + 125, + 166, + 125, + 250, + 917, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 541, + 125, + 167, + 125, + 167, + 166, + 84, + 166, + 125, + 125, + 167, + 958, + 167, + 292, + 2041, + 167, + 9542, + 250, + 125, + 208, + 250, + 125, + 83, + 125, + 167, + 125, + 208, + 17792, + 583, + 417, + 2708, + 1542, + 625, + 167, + 166, + 334, + 166, + 125, + 375, + 167, + 167, + 541, + 125, + 167, + 125, + 125, + 125, + 125, + 458, + 125, + 167, + 167, + 125, + 166, + 209, + 208, + 125, + 208, + 167, + 167, + 166, + 250, + 167, + 83, + 125, + 167, + 167, + 166, + 167, + 208, + 167, + 167, + 166, + 125, + 167, + 167, + 250, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 209, + 125, + 666, + 167, + 83, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 375, + 208, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 83, + 209, + 208, + 167, + 166, + 209, + 416, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 541, + 125, + 250, + 167, + 125, + 167, + 166, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 250, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 334, + 83, + 125, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 333, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 250, + 167, + 125, + 167, + 166, + 167, + 167, + 41, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 292, + 208, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 41, + 84, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 250, + 1916, + 292, + 292, + 125, + 166, + 3875, + 125, + 709, + 958, + 167, + 1000, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 250, + 125, + 166, + 167, + 83, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 167, + 167, + 250, + 166, + 125, + 167, + 167, + 250, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 42, + 83, + 167, + 125, + 208, + 250, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 375, + 83, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 333, + 42, + 125, + 125, + 166, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 250, + 167, + 208, + 84, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 125, + 166, + 84, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 42, + 83, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 208, + 167, + 167, + 416, + 125, + 84, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 333, + 250, + 125, + 167, + 125, + 125, + 167, + 208, + 333, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 84, + 208, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 334, + 208, + 167, + 1916, + 459, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 333, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 208, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 84, + 125, + 166, + 167, + 83, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 42, + 166, + 250, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 583, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 0, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 83, + 125, + 125, + 167, + 125, + 167, + 83, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 42, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 375, + 0, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 333, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 333, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 166, + 1375, + 167, + 125, + 167, + 250, + 166, + 125, + 459, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 41, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 83, + 417, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 83, + 167, + 375, + 41, + 125, + 209, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 458, + 500, + 167, + 208, + 1500, + 1084, + 875, + 208, + 167, + 208, + 167, + 208, + 167, + 125, + 166, + 125, + 167, + 167, + 83, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 84, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 250, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 125, + 83, + 167, + 125, + 167, + 83, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 83, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 584, + 166, + 209, + 416, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 458, + 83, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 83, + 167, + 250, + 166, + 167, + 125, + 208, + 125, + 167, + 208, + 167, + 208, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 84, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 250, + 125, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 208, + 83, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 291, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 0, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 417, + 458, + 84, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 83, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 250, + 250, + 125, + 83, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 107958, + 5709, + 3583, + 1917, + 13958, + 11333, + 125, + 459, + 1375, + 1125, + 375, + 541, + 375, + 125, + 250, + 375, + 834, + 208, + 167, + 208, + 208, + 292, + 167, + 333, + 458, + 667, + 375, + 500, + 125, + 542, + 41, + 292, + 1917, + 83, + 167, + 125, + 125, + 166, + 625, + 292, + 542, + 708, + 83, + 250, + 167, + 83, + 292, + 125, + 167, + 125, + 125, + 291, + 84, + 125, + 125, + 250, + 333, + 125, + 125, + 125, + 83, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 375, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 750, + 292, + 125, + 1250, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 333, + 334, + 333, + 125, + 208, + 167, + 125, + 458, + 125, + 125, + 167, + 958, + 375, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 209, + 291, + 334, + 83, + 42, + 125, + 250, + 416, + 42, + 83, + 125, + 334, + 41, + 292, + 292, + 208, + 292, + 125, + 166, + 84, + 875, + 625, + 583, + 542, + 83, + 125, + 167, + 125, + 1333, + 125, + 83, + 125, + 167, + 125, + 1458, + 500, + 750, + 167, + 167, + 83, + 125, + 167, + 708, + 1042, + 166, + 125, + 167, + 875, + 2708, + 167, + 375, + 292, + 83, + 125, + 208, + 209, + 125, + 166, + 1292, + 208, + 375, + 209, + 291, + 917, + 750, + 0, + 333, + 250, + 42, + 292, + 250, + 416, + 0, + 250, + 84, + 666, + 1334, + 41, + 292, + 250, + 583, + 292, + 125, + 167, + 208, + 167, + 83, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 84, + 166, + 417, + 458, + 125, + 417, + 0, + 167, + 458, + 167, + 166, + 375, + 42, + 417, + 333, + 375, + 42, + 500, + 208, + 42, + 166, + 167, + 167, + 208, + 167, + 166, + 250, + 500, + 167, + 375, + 42, + 208, + 208, + 167, + 167, + 500, + 0, + 125, + 208, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 250, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 667, + 41, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 250, + 833, + 250, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 83, + 125, + 167, + 125, + 500, + 208, + 84, + 125, + 166, + 167, + 125, + 167, + 291, + 250, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 875, + 167, + 208, + 458, + 542, + 500, + 917, + 500, + 2083, + 875, + 208, + 375, + 125, + 459, + 375, + 833, + 250, + 458, + 167, + 292, + 125, + 208, + 167, + 291, + 167, + 292, + 166, + 250, + 292, + 167, + 416, + 42, + 250, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 333, + 125, + 167, + 125, + 125, + 125, + 416, + 375, + 84, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 166, + 125, + 209, + 291, + 125, + 209, + 166, + 167, + 167, + 125, + 166, + 167, + 500, + 125, + 167, + 208, + 167, + 125, + 166, + 250, + 0, + 167, + 167, + 333, + 167, + 125, + 250, + 125, + 166, + 125, + 125, + 167, + 208, + 459, + 166, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 291, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 625, + 41, + 209, + 208, + 83, + 209, + 166, + 125, + 209, + 666, + 167, + 333, + 125, + 167, + 250, + 125, + 333, + 167, + 417, + 208, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 42, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 167, + 208, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 83, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 250, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 208, + 125, + 167, + 167, + 125, + 250, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 292, + 125, + 125, + 167, + 125, + 125, + 125, + 250, + 125, + 166, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 41, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 292, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 250, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 83, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 375, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 208, + 125, + 167, + 125, + 125, + 250, + 167, + 166, + 209, + 208, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 125, + 250, + 209, + 125, + 166, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 208, + 333, + 167, + 167, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 250, + 209, + 83, + 167, + 125, + 250, + 208, + 167, + 125, + 166, + 84, + 125, + 291, + 167, + 208, + 42, + 167, + 125, + 416, + 167, + 42, + 166, + 459, + 83, + 208, + 292, + 42, + 166, + 209, + 125, + 250, + 125, + 166, + 417, + 125, + 167, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 625, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 291, + 125, + 125, + 125, + 167, + 167, + 208, + 125, + 167, + 625, + 125, + 125, + 125, + 125, + 166, + 250, + 292, + 167, + 541, + 125, + 167, + 208, + 209, + 458, + 125, + 167, + 458, + 125, + 542, + 500, + 166, + 125, + 167, + 250, + 83, + 84, + 250, + 125, + 125, + 166, + 167, + 125, + 333, + 250, + 125, + 125, + 209, + 250, + 166, + 167, + 125, + 167, + 125, + 416, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 292, + 292, + 166, + 209, + 166, + 292, + 1042, + 708, + 417, + 166, + 84, + 208, + 125, + 208, + 125, + 167, + 125, + 83, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 208, + 1958, + 167, + 292, + 208, + 208, + 334, + 166, + 250, + 250, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 167, + 291, + 167, + 167, + 166, + 125, + 167, + 208, + 209, + 291, + 209, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 250, + 125, + 167, + 125, + 125, + 166, + 167, + 208, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 83, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 250, + 167, + 166, + 167, + 167, + 166, + 125, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 125, + 167, + 166, + 167, + 125, + 83, + 167, + 125, + 167, + 125, + 83, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 250, + 250, + 167, + 166, + 250, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 209, + 208, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 84, + 166, + 125, + 125, + 125, + 209, + 208, + 125, + 208, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 84, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 917, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 209, + 83, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 84, + 166, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 209, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 209, + 166, + 84, + 125, + 125, + 250, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 584, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 41, + 84, + 125, + 166, + 84, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 8083, + 1000, + 250, + 2208, + 375, + 4875, + 33875, + 41292, + 34042, + 9625, + 166, + 125, + 542, + 292, + 125, + 166, + 125, + 500, + 125, + 125, + 167, + 4417, + 125, + 1125, + 250, + 208, + 167, + 166, + 292, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 209, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 416, + 167, + 4083, + 125, + 125, + 167, + 167, + 875, + 166, + 125, + 125, + 167, + 1125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 667, + 333, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 459, + 125, + 166, + 417, + 167, + 958, + 167, + 1416, + 375, + 750, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 3417, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 250, + 167, + 166, + 2917, + 167, + 208, + 167, + 125, + 8125, + 23500, + 125, + 1333, + 167, + 208, + 2250, + 583, + 417, + 708, + 2417, + 21958, + 1375, + 167, + 167, + 83, + 125, + 167, + 125, + 166, + 1167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 292, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 292, + 125, + 125, + 125, + 292, + 458, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 42, + 166, + 125, + 209, + 166, + 125, + 167, + 125, + 167, + 83, + 125, + 125, + 167, + 333, + 125, + 167, + 125, + 125, + 208, + 583, + 84, + 250, + 291, + 167, + 83, + 167, + 167, + 125, + 125, + 166, + 792, + 333, + 125, + 209, + 125, + 250, + 125, + 1291, + 125, + 125, + 125, + 84, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 666, + 209, + 166, + 125, + 167, + 167, + 916, + 167, + 125, + 6333, + 750, + 834, + 208, + 167, + 166, + 584, + 125, + 166, + 334, + 291, + 250, + 125, + 209, + 375, + 250, + 125, + 375, + 291, + 375, + 417, + 375, + 167, + 166, + 250, + 375, + 125, + 417, + 250, + 500, + 625, + 708, + 167, + 1917, + 416, + 84, + 375, + 125, + 1250, + 333, + 958, + 542, + 167, + 958, + 292, + 458, + 583, + 292, + 167, + 291, + 875, + 167, + 833, + 5250, + 9500, + 3625, + 375, + 417, + 1042, + 416, + 667, + 625, + 917, + 47958, + 1875, + 14333, + 98709, + 1041, + 2292, + 875, + 167, + 750, + 3833, + 917, + 958, + 30417, + 2458, + 125, + 1500, + 167, + 958, + 125, + 1125, + 333, + 834, + 458, + 292, + 583, + 2417, + 83, + 1500, + 125, + 2042, + 666, + 834, + 166, + 167, + 125, + 583, + 250, + 375, + 667, + 208, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 333, + 84, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 500, + 84, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 292, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 83, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 83, + 208, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 209, + 125, + 166, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 208, + 125, + 125, + 125, + 167, + 417, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 209, + 208, + 125, + 167, + 125, + 125, + 166, + 167, + 208, + 209, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 208, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 334, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 709, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 250, + 167, + 208, + 167, + 208, + 209, + 166, + 167, + 125, + 125, + 208, + 125, + 209, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 167, + 166, + 84, + 208, + 167, + 166, + 125, + 167, + 208, + 209, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 167, + 166, + 167, + 875, + 1000, + 625, + 458, + 125, + 1084, + 833, + 1208, + 750, + 584, + 125, + 125, + 291, + 417, + 375, + 958, + 334, + 250, + 333, + 2042, + 875, + 625, + 791, + 125, + 125, + 1250, + 459, + 166, + 959, + 166, + 417, + 125, + 125, + 167, + 333, + 125, + 167, + 250, + 166, + 167, + 125, + 167, + 291, + 125, + 167, + 125, + 167, + 166, + 459, + 375, + 166, + 167, + 375, + 167, + 875, + 333, + 167, + 250, + 166, + 292, + 125, + 500, + 500, + 292, + 166, + 375, + 334, + 125, + 125, + 166, + 292, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 208, + 167, + 208, + 167, + 167, + 166, + 375, + 250, + 167, + 250, + 333, + 459, + 166, + 500, + 709, + 250, + 125, + 166, + 667, + 208, + 417, + 2000, + 417, + 833, + 833, + 459, + 625, + 166, + 750, + 250, + 167, + 500, + 250, + 167, + 291, + 250, + 209, + 291, + 167, + 208, + 625, + 167, + 167, + 250, + 666, + 167, + 167, + 375, + 250, + 416, + 209, + 208, + 250, + 167, + 208, + 208, + 167, + 458, + 542, + 167, + 958, + 292, + 541, + 459, + 166, + 167, + 375, + 208, + 125, + 167, + 375, + 417, + 166, + 167, + 458, + 209, + 166, + 209, + 208, + 167, + 166, + 167, + 375, + 417, + 208, + 1375, + 792, + 458, + 167, + 250, + 208, + 208, + 167, + 167, + 166, + 334, + 125, + 208, + 125, + 167, + 208, + 167, + 166, + 375, + 250, + 209, + 125, + 166, + 209, + 375, + 166, + 167, + 167, + 166, + 167, + 542, + 166, + 167, + 750, + 167, + 208, + 83, + 125, + 209, + 125, + 125, + 125, + 458, + 250, + 167, + 166, + 125, + 167, + 333, + 167, + 167, + 166, + 167, + 125, + 167, + 375, + 166, + 584, + 0, + 125, + 166, + 167, + 125, + 208, + 292, + 125, + 167, + 166, + 250, + 167, + 125, + 125, + 208, + 167, + 167, + 166, + 167, + 167, + 333, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 83, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 291, + 209, + 166, + 125, + 209, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 84, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 208, + 167, + 167, + 125, + 166, + 167, + 167, + 208, + 125, + 250, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 208, + 167, + 125, + 125, + 416, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 166, + 167, + 83, + 125, + 250, + 125, + 125, + 167, + 208, + 292, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 250, + 208, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 2542, + 208, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 292, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 542, + 2000, + 208, + 167, + 125, + 208, + 167, + 125, + 166, + 125, + 125, + 209, + 208, + 167, + 208, + 83, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 250, + 625, + 500, + 125, + 250, + 125, + 167, + 125, + 125, + 125, + 583, + 1458, + 7209, + 4000, + 1583, + 417, + 166, + 125, + 125, + 167, + 167, + 291, + 167, + 125, + 292, + 125, + 166, + 125, + 250, + 542, + 11250, + 3583, + 59000, + 13334, + 208, + 292, + 125, + 166, + 167, + 250, + 83, + 167, + 167, + 166, + 167, + 125, + 167, + 333, + 1083, + 209, + 833, + 125, + 125, + 208, + 1292, + 208, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 375, + 166, + 125, + 125, + 167, + 458, + 167, + 167, + 166, + 292, + 167, + 166, + 84, + 166, + 125, + 19667, + 2125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 250, + 209, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 459, + 125, + 125, + 166, + 167, + 83, + 625, + 42, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 250, + 125, + 166, + 125, + 167, + 125, + 167, + 291, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 541, + 167, + 167, + 125, + 166, + 209, + 125, + 1083, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 83, + 167, + 2083, + 250, + 292, + 250, + 1875, + 166, + 167, + 125, + 125, + 1167, + 416, + 167, + 500, + 417, + 291, + 250, + 750, + 334, + 416, + 167, + 250, + 167, + 458, + 1625, + 167, + 2333, + 333, + 209, + 166, + 250, + 1709, + 1541, + 750, + 209, + 125, + 291, + 125, + 167, + 333, + 459, + 708, + 333, + 750, + 209, + 125, + 291, + 292, + 125, + 250, + 375, + 167, + 208, + 208, + 167, + 208, + 209, + 166, + 167, + 208, + 167, + 167, + 208, + 333, + 167, + 167, + 208, + 625, + 167, + 166, + 125, + 167, + 125, + 167, + 83, + 375, + 250, + 167, + 250, + 166, + 125, + 167, + 250, + 125, + 125, + 292, + 250, + 291, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 208, + 167, + 125, + 167, + 125, + 125, + 166, + 209, + 166, + 292, + 417, + 166, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 83, + 125, + 125, + 125, + 209, + 166, + 125, + 209, + 125, + 166, + 125, + 84, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 250, + 125, + 167, + 83, + 167, + 291, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 500, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 333, + 167, + 167, + 125, + 333, + 167, + 83, + 167, + 166, + 125, + 125, + 167, + 125, + 250, + 167, + 125, + 125, + 166, + 167, + 208, + 459, + 958, + 208, + 167, + 125, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 375, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 667, + 42, + 125, + 125, + 583, + 1792, + 125, + 958, + 2125, + 4250, + 2083, + 3375, + 2459, + 2833, + 1375, + 2167, + 12333, + 583, + 2000, + 1250, + 1250, + 3209, + 3583, + 875, + 2375, + 208, + 667, + 833, + 2500, + 2334, + 2791, + 5292, + 3708, + 3667, + 3208, + 1125, + 1042, + 3042, + 875, + 1333, + 2042, + 2958, + 833, + 1209, + 125, + 166, + 125, + 167, + 125, + 625, + 292, + 583, + 250, + 250, + 542, + 291, + 167, + 167, + 208, + 250, + 250, + 542, + 166, + 292, + 125, + 583, + 1834, + 1000, + 1541, + 167, + 500, + 625, + 292, + 500, + 1083, + 1708, + 1667, + 125, + 708, + 209, + 125, + 208, + 167, + 166, + 125, + 125, + 167, + 208, + 167, + 125, + 125, + 125, + 708, + 125, + 125, + 125, + 334, + 125, + 666, + 292, + 167, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 833, + 125, + 959, + 12541, + 3959, + 2416, + 375, + 542, + 917, + 208, + 583, + 459, + 166, + 125, + 292, + 583, + 250, + 125, + 167, + 625, + 750, + 125, + 167, + 208, + 208, + 1292, + 208, + 459, + 291, + 584, + 208, + 208, + 167, + 167, + 166, + 167, + 625, + 250, + 125, + 208, + 375, + 125, + 125, + 125, + 334, + 125, + 125, + 208, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 333, + 167, + 125, + 208, + 209, + 166, + 125, + 209, + 125, + 125, + 125, + 208, + 167, + 208, + 125, + 167, + 166, + 167, + 1292, + 125, + 166, + 250, + 250, + 209, + 125, + 333, + 250, + 167, + 583, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 292, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 209, + 125, + 208, + 125, + 125, + 167, + 208, + 125, + 83, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 208, + 125, + 209, + 250, + 208, + 208, + 167, + 167, + 208, + 167, + 166, + 292, + 167, + 27541, + 40959, + 9791, + 250, + 250, + 167, + 2375, + 3583, + 250, + 9500, + 209, + 208, + 125, + 167, + 125, + 583, + 417, + 208, + 208, + 125, + 334, + 166, + 125, + 167, + 417, + 166, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 208, + 2208, + 2042, + 833, + 375, + 584, + 375, + 14250, + 8250, + 2291, + 125, + 209, + 333, + 417, + 250, + 416, + 167, + 292, + 333, + 250, + 375, + 375, + 292, + 166, + 417, + 208, + 167, + 167, + 166, + 167, + 250, + 292, + 208, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 208, + 334, + 125, + 208, + 167, + 250, + 166, + 292, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 292, + 125, + 125, + 166, + 167, + 167, + 333, + 125, + 167, + 125, + 125, + 125, + 291, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 84, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 208, + 125, + 167, + 208, + 209, + 291, + 167, + 125, + 167, + 208, + 167, + 166, + 375, + 125, + 209, + 166, + 209, + 166, + 125, + 84, + 250, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 208, + 125, + 250, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 917, + 166, + 209, + 125, + 166, + 84, + 125, + 166, + 125, + 209, + 166, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 250, + 125, + 584, + 125, + 166, + 167, + 208, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 83, + 209, + 166, + 125, + 167, + 292, + 250, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 334, + 208, + 208, + 250, + 250, + 250, + 167, + 167, + 208, + 167, + 291, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 84, + 125, + 166, + 167, + 250, + 125, + 125, + 125, + 167, + 208, + 250, + 125, + 167, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 208, + 125, + 208, + 167, + 167, + 125, + 208, + 292, + 125, + 166, + 125, + 334, + 125, + 125, + 125, + 375, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 250, + 125, + 125, + 167, + 250, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 625, + 83, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 167, + 250, + 125, + 250, + 417, + 166, + 167, + 208, + 209, + 208, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 250, + 416, + 209, + 125, + 208, + 125, + 167, + 125, + 166, + 417, + 167, + 250, + 166, + 500, + 209, + 375, + 166, + 167, + 458, + 167, + 208, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 292, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 83, + 209, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 208, + 167, + 83, + 250, + 84, + 125, + 125, + 166, + 167, + 125, + 167, + 291, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 292, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 83, + 167, + 125, + 166, + 167, + 167, + 125, + 250, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 250, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 209, + 250, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 250, + 125, + 167, + 166, + 250, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 417, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 250, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 208, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 250, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 209, + 166, + 167, + 167, + 125, + 125, + 166, + 84, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 208, + 125, + 208, + 125, + 125, + 167, + 167, + 208, + 167, + 125, + 125, + 166, + 84, + 125, + 166, + 167, + 167, + 166, + 209, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 208, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 250, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 291, + 84, + 208, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 625, + 125, + 167, + 292, + 208, + 208, + 209, + 166, + 125, + 167, + 167, + 208, + 333, + 125, + 125, + 125, + 167, + 208, + 167, + 167, + 166, + 209, + 125, + 208, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 250, + 167, + 166, + 167, + 167, + 208, + 167, + 166, + 209, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 333, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 208, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 250, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 209, + 125, + 125, + 125, + 208, + 167, + 125, + 125, + 125, + 166, + 209, + 125, + 458, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 1625, + 167, + 333, + 250, + 125, + 167, + 166, + 250, + 334, + 208, + 1000, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 208, + 125, + 167, + 125, + 125, + 167, + 208, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 292, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 83, + 209, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 209, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 208, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 83, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 83, + 208, + 167, + 125, + 208, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 208, + 333, + 167, + 458, + 6667, + 375, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 83, + 167, + 167, + 166, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 84, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 250, + 250, + 208, + 334, + 166, + 209, + 166, + 375, + 125, + 84, + 125, + 416, + 167, + 292, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 250, + 375, + 334, + 125, + 166, + 125, + 125, + 750, + 209, + 125, + 166, + 125, + 209, + 125, + 541, + 125, + 625, + 209, + 166, + 167, + 125, + 292, + 375, + 125, + 833, + 167, + 125, + 208, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 84, + 291, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 292, + 166, + 167, + 125, + 167, + 208, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 166, + 167, + 167, + 250, + 166, + 209, + 125, + 166, + 125, + 250, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 167, + 167, + 291, + 250, + 334, + 125, + 166, + 125, + 167, + 167, + 166, + 250, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 208, + 167, + 167, + 125, + 125, + 125, + 166, + 250, + 125, + 250, + 167, + 250, + 208, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 83, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 83, + 167, + 250, + 125, + 208, + 375, + 167, + 208, + 209, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 209, + 166, + 125, + 167, + 208, + 209, + 208, + 250, + 292, + 166, + 209, + 166, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 250, + 167, + 333, + 708, + 209, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 166, + 167, + 83, + 125, + 125, + 167, + 250, + 125, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 250, + 125, + 209, + 125, + 125, + 166, + 250, + 125, + 125, + 125, + 250, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 83, + 125, + 125, + 125, + 209, + 166, + 167, + 417, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 166, + 125, + 167, + 6958, + 3542, + 1042, + 500, + 1125, + 1125, + 208, + 5125, + 833, + 7084, + 8166, + 3292, + 167, + 3458, + 292, + 4291, + 250, + 3500, + 37000, + 125, + 29459, + 166, + 459, + 125, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 208, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 208, + 84, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 250, + 208, + 125, + 167, + 3875, + 917, + 1416, + 917, + 24042, + 10625, + 2833, + 2500, + 7542, + 666, + 4667, + 1125, + 500, + 667, + 458, + 292, + 458, + 667, + 1625, + 750, + 333, + 167, + 250, + 541, + 1750, + 334, + 166, + 250, + 334, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 375, + 125, + 166, + 125, + 167, + 625, + 375, + 125, + 125, + 167, + 208, + 333, + 167, + 83, + 167, + 167, + 125, + 250, + 125, + 125, + 166, + 500, + 84, + 166, + 125, + 167, + 167, + 250, + 166, + 167, + 250, + 167, + 166, + 167, + 208, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 83, + 167, + 167, + 125, + 250, + 125, + 166, + 125, + 167, + 125, + 125, + 625, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 209, + 250, + 208, + 250, + 125, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 209, + 166, + 167, + 83, + 209, + 125, + 125, + 583, + 125, + 125, + 167, + 291, + 167, + 167, + 208, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 208, + 125, + 167, + 125, + 208, + 125, + 208, + 209, + 166, + 250, + 125, + 125, + 167, + 125, + 250, + 500, + 125, + 125, + 208, + 292, + 125, + 167, + 125, + 125, + 208, + 125, + 208, + 125, + 125, + 459, + 208, + 208, + 417, + 2958, + 292, + 1167, + 333, + 917, + 208, + 792, + 208, + 167, + 83, + 167, + 291, + 667, + 292, + 208, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 125, + 125, + 125, + 167, + 167, + 208, + 167, + 166, + 167, + 83, + 125, + 84, + 208, + 125, + 125, + 125, + 167, + 166, + 875, + 625, + 167, + 125, + 125, + 208, + 125, + 167, + 250, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 250, + 125, + 125, + 125, + 125, + 292, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 292, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 1125, + 375, + 166, + 125, + 209, + 208, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 83, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 41, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 42, + 167, + 208, + 250, + 208, + 167, + 125, + 167, + 208, + 250, + 167, + 125, + 125, + 166, + 167, + 250, + 208, + 334, + 166, + 167, + 125, + 208, + 167, + 208, + 209, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 208, + 167, + 125, + 125, + 250, + 250, + 167, + 166, + 167, + 167, + 208, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 292, + 250, + 333, + 250, + 125, + 250, + 209, + 125, + 166, + 167, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 292, + 292, + 166, + 459, + 125, + 166, + 167, + 125, + 250, + 375, + 208, + 250, + 459, + 250, + 166, + 167, + 125, + 250, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 209, + 125, + 208, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 250, + 125, + 208, + 250, + 167, + 1667, + 3041, + 125, + 209, + 166, + 125, + 125, + 167, + 167, + 291, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 292, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 83, + 125, + 125, + 125, + 209, + 208, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 209, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 250, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 166, + 125, + 167, + 208, + 167, + 125, + 208, + 125, + 84, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 209, + 166, + 167, + 208, + 167, + 83, + 125, + 167, + 167, + 166, + 250, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 84, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 250, + 209, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 167, + 167, + 166, + 125, + 125, + 125, + 209, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 84, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 209, + 125, + 166, + 125, + 209, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 209, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 209, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 250, + 334, + 125, + 166, + 209, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 83, + 167, + 166, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 250, + 167, + 125, + 166, + 125, + 167, + 208, + 125, + 125, + 209, + 166, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 375, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 209, + 166, + 125, + 292, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 84, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 84, + 166, + 167, + 208, + 125, + 125, + 209, + 291, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 250, + 125, + 167, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 209, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 125, + 167, + 166, + 125, + 250, + 167, + 167, + 166, + 250, + 209, + 125, + 166, + 292, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 250, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 125, + 166, + 167, + 125, + 125, + 83, + 167, + 125, + 125, + 208, + 84, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 334, + 208, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 250, + 83, + 167, + 125, + 166, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 15208, + 625, + 375, + 209, + 12791, + 1250, + 3750, + 209, + 208, + 500, + 292, + 625, + 291, + 792, + 792, + 375, + 375, + 1708, + 250, + 458, + 1167, + 2792, + 1583, + 8125, + 1542, + 7208, + 1625, + 292, + 166, + 209, + 333, + 292, + 166, + 125, + 250, + 167, + 250, + 542, + 791, + 125, + 250, + 292, + 250, + 208, + 167, + 125, + 167, + 125, + 291, + 209, + 1000, + 166, + 334, + 500, + 208, + 542, + 2666, + 8125, + 35875, + 959, + 291, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 333, + 167, + 166, + 167, + 167, + 166, + 209, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 2583, + 167, + 125, + 208, + 167, + 375, + 208, + 167, + 125, + 125, + 167, + 250, + 125, + 166, + 167, + 125, + 125, + 167, + 16750, + 10458, + 375, + 125, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 292, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 583, + 542, + 250, + 667, + 1083, + 250, + 625, + 500, + 250, + 292, + 208, + 583, + 250, + 167, + 292, + 958, + 167, + 2291, + 792, + 3042, + 791, + 209, + 1125, + 1375, + 1625, + 1625, + 208, + 333, + 375, + 542, + 292, + 125, + 166, + 667, + 292, + 250, + 333, + 750, + 208, + 334, + 250, + 250, + 250, + 666, + 667, + 208, + 417, + 417, + 166, + 417, + 750, + 292, + 541, + 167, + 125, + 333, + 125, + 250, + 167, + 167, + 208, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 334, + 166, + 250, + 125, + 167, + 125, + 417, + 166, + 167, + 208, + 125, + 209, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 83, + 250, + 333, + 167, + 125, + 167, + 166, + 209, + 166, + 167, + 208, + 167, + 167, + 125, + 208, + 167, + 166, + 125, + 125, + 167, + 125, + 292, + 125, + 166, + 125, + 167, + 208, + 167, + 125, + 208, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 458, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 167, + 166, + 125, + 250, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 166, + 125, + 250, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 83, + 125, + 125, + 125, + 375, + 209, + 125, + 166, + 167, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 208, + 167, + 125, + 166, + 125, + 84, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 625, + 167, + 291, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 125, + 125, + 250, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 167, + 250, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 333, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 209, + 166, + 167, + 208, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 84, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 250, + 167, + 125, + 125, + 125, + 167, + 208, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 208, + 250, + 167, + 83, + 167, + 167, + 125, + 291, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 542, + 125, + 167, + 916, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 209, + 166, + 167, + 167, + 208, + 125, + 167, + 208, + 125, + 500, + 208, + 167, + 208, + 167, + 125, + 208, + 125, + 167, + 167, + 166, + 167, + 125, + 208, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 167, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 250, + 125, + 125, + 209, + 166, + 209, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 375, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 84, + 208, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 375, + 208, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 208, + 208, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 167, + 208, + 208, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 209, + 583, + 167, + 125, + 166, + 209, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 83, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 333, + 125, + 167, + 166, + 125, + 417, + 292, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 208, + 292, + 166, + 209, + 166, + 125, + 250, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 209, + 166, + 167, + 83, + 125, + 167, + 167, + 166, + 167, + 83, + 167, + 125, + 208, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 209, + 83, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 250, + 166, + 167, + 42, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 166, + 125, + 209, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 84, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 83, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 458, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 84, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 625, + 125, + 166, + 125, + 167, + 125, + 167, + 708, + 167, + 291, + 167, + 167, + 166, + 167, + 167, + 125, + 208, + 125, + 167, + 291, + 125, + 167, + 125, + 417, + 0, + 166, + 167, + 250, + 18417, + 4625, + 1583, + 292, + 333, + 22625, + 13625, + 1542, + 3541, + 125, + 9625, + 167, + 26208, + 11209, + 166, + 167, + 208, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 250, + 167, + 40041, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 416, + 167, + 167, + 166, + 84, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 125, + 250, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 250, + 125, + 125, + 125, + 125, + 291, + 84, + 166, + 167, + 167, + 83, + 333, + 167, + 125, + 208, + 125, + 417, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 291, + 167, + 208, + 125, + 167, + 167, + 375, + 125, + 125, + 291, + 125, + 209, + 250, + 166, + 125, + 209, + 250, + 125, + 166, + 125, + 125, + 250, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 292, + 125, + 125, + 125, + 166, + 125, + 209, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 250, + 125, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 84, + 166, + 167, + 167, + 125, + 125, + 333, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 541, + 375, + 167, + 167, + 166, + 125, + 125, + 250, + 167, + 167, + 166, + 334, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 333, + 125, + 167, + 125, + 291, + 125, + 167, + 125, + 208, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 83, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 208, + 125, + 167, + 333, + 167, + 125, + 125, + 166, + 167, + 125, + 208, + 167, + 167, + 250, + 125, + 125, + 375, + 166, + 125, + 167, + 167, + 208, + 167, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 250, + 125, + 167, + 167, + 375, + 125, + 125, + 125, + 541, + 167, + 375, + 167, + 166, + 125, + 125, + 334, + 166, + 125, + 167, + 125, + 375, + 167, + 166, + 125, + 250, + 125, + 167, + 167, + 166, + 167, + 125, + 250, + 167, + 166, + 125, + 125, + 209, + 125, + 208, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 208, + 125, + 375, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 292, + 166, + 209, + 250, + 166, + 209, + 125, + 250, + 125, + 250, + 166, + 334, + 166, + 167, + 292, + 125, + 166, + 125, + 250, + 125, + 167, + 167, + 291, + 125, + 167, + 292, + 208, + 125, + 125, + 333, + 125, + 209, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 250, + 208, + 167, + 125, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 125, + 208, + 84, + 166, + 209, + 166, + 167, + 208, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 333, + 125, + 125, + 250, + 292, + 250, + 166, + 125, + 167, + 250, + 167, + 166, + 167, + 167, + 125, + 208, + 208, + 167, + 167, + 208, + 125, + 208, + 250, + 125, + 417, + 167, + 166, + 334, + 83, + 167, + 125, + 125, + 333, + 125, + 167, + 166, + 125, + 792, + 417, + 250, + 166, + 125, + 167, + 125, + 125, + 208, + 209, + 125, + 250, + 166, + 209, + 125, + 208, + 167, + 166, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 209, + 166, + 125, + 209, + 166, + 209, + 208, + 167, + 166, + 167, + 167, + 166, + 334, + 250, + 208, + 167, + 125, + 125, + 166, + 125, + 167, + 208, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 250, + 166, + 167, + 125, + 208, + 125, + 125, + 167, + 208, + 209, + 166, + 209, + 166, + 167, + 250, + 125, + 83, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 209, + 166, + 167, + 167, + 166, + 125, + 167, + 375, + 167, + 166, + 375, + 542, + 125, + 125, + 167, + 166, + 167, + 208, + 167, + 250, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 208, + 208, + 167, + 125, + 208, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 250, + 125, + 167, + 166, + 209, + 166, + 209, + 166, + 125, + 84, + 166, + 167, + 125, + 83, + 209, + 166, + 125, + 209, + 291, + 1875, + 167, + 83, + 167, + 250, + 125, + 167, + 125, + 166, + 250, + 167, + 167, + 208, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 209, + 166, + 125, + 209, + 166, + 209, + 125, + 250, + 125, + 166, + 125, + 125, + 209, + 125, + 416, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 292, + 208, + 167, + 125, + 166, + 167, + 125, + 167, + 208, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 209, + 125, + 125, + 208, + 125, + 208, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 208, + 125, + 208, + 167, + 125, + 125, + 125, + 167, + 166, + 209, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 125, + 209, + 166, + 167, + 167, + 166, + 250, + 84, + 125, + 125, + 166, + 250, + 167, + 167, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 208, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 208, + 125, + 167, + 208, + 167, + 167, + 125, + 166, + 209, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 41, + 125, + 125, + 167, + 167, + 166, + 167, + 208, + 125, + 167, + 167, + 208, + 167, + 125, + 208, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 209, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 84, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 209, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 42, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 84, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 417, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 500, + 83, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 458, + 125, + 125, + 209, + 208, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 166, + 84, + 250, + 125, + 2458, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 208, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 292, + 166, + 209, + 625, + 250, + 208, + 83, + 167, + 458, + 209, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 10625, + 4958, + 1500, + 1000, + 292, + 375, + 250, + 292, + 1333, + 1208, + 834, + 625, + 458, + 1417, + 541, + 959, + 541, + 500, + 2750, + 500, + 3042, + 1708, + 667, + 1083, + 1834, + 416, + 292, + 375, + 417, + 416, + 459, + 250, + 208, + 208, + 125, + 500, + 209, + 208, + 458, + 6417, + 417, + 2708, + 6417, + 15875, + 875, + 4083, + 33292, + 2291, + 31417, + 4583, + 750, + 2292, + 375, + 708, + 250, + 250, + 292, + 208, + 500, + 167, + 125, + 125, + 292, + 250, + 333, + 250, + 167, + 333, + 125, + 208, + 84, + 375, + 166, + 125, + 167, + 875, + 125, + 500, + 458, + 667, + 250, + 375, + 542, + 458, + 208, + 84, + 166, + 417, + 83, + 209, + 541, + 292, + 125, + 208, + 167, + 83, + 125, + 167, + 167, + 375, + 0, + 291, + 250, + 292, + 42, + 208, + 500, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 83, + 959, + 250, + 375, + 333, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 542, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 208, + 167, + 166, + 167, + 83, + 42, + 125, + 125, + 167, + 5000, + 12208, + 5375, + 6833, + 250, + 625, + 250, + 84, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 209, + 41, + 167, + 167, + 416, + 125, + 292, + 83, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 166, + 375, + 292, + 417, + 208, + 167, + 208, + 125, + 333, + 292, + 83, + 334, + 83, + 333, + 250, + 0, + 292, + 167, + 250, + 83, + 333, + 292, + 42, + 291, + 42, + 375, + 292, + 291, + 334, + 416, + 42, + 250, + 42, + 250, + 250, + 416, + 667, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 500, + 166, + 250, + 84, + 125, + 125, + 166, + 167, + 250, + 500, + 167, + 166, + 500, + 209, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 250, + 167, + 125, + 167, + 125, + 166, + 167, + 83, + 209, + 291, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 209, + 125, + 166, + 167, + 83, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 917, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 209, + 125, + 333, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 167, + 125, + 125, + 167, + 125, + 83, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 250, + 167, + 125, + 208, + 84, + 125, + 166, + 209, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 250, + 208, + 125, + 250, + 125, + 167, + 167, + 166, + 125, + 125, + 209, + 166, + 167, + 167, + 166, + 125, + 125, + 209, + 208, + 167, + 166, + 209, + 166, + 125, + 167, + 167, + 166, + 125, + 209, + 166, + 167, + 167, + 125, + 166, + 125, + 250, + 250, + 125, + 125, + 209, + 125, + 166, + 167, + 125, + 208, + 209, + 166, + 417, + 333, + 42, + 167, + 166, + 125, + 375, + 167, + 167, + 125, + 250, + 291, + 375, + 292, + 83, + 417, + 0, + 625, + 292, + 208, + 167, + 125, + 250, + 250, + 250, + 375, + 41, + 459, + 625, + 291, + 125, + 459, + 291, + 84, + 166, + 292, + 167, + 166, + 167, + 125, + 542, + 291, + 209, + 666, + 125, + 250, + 125, + 125, + 417, + 875, + 125, + 167, + 125, + 291, + 84, + 250, + 125, + 208, + 292, + 166, + 167, + 125, + 250, + 458, + 125, + 167, + 208, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 0, + 125, + 83, + 125, + 209, + 83, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 209, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 459, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 84, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 666, + 42, + 167, + 125, + 125, + 458, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 291, + 42, + 83, + 250, + 125, + 167, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 12125, + 7459, + 3250, + 291, + 250, + 917, + 542, + 958, + 2542, + 416, + 250, + 334, + 458, + 292, + 250, + 250, + 250, + 5833, + 333, + 1625, + 3250, + 125, + 36709, + 15333, + 1625, + 167, + 250, + 166, + 167, + 333, + 42, + 208, + 375, + 375, + 292, + 83, + 334, + 416, + 0, + 375, + 250, + 167, + 375, + 458, + 1125, + 209, + 1916, + 209, + 1000, + 291, + 10542, + 7375, + 8458, + 459, + 208, + 250, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 291, + 250, + 42, + 125, + 333, + 84, + 166, + 375, + 292, + 333, + 42, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 208, + 375, + 250, + 417, + 208, + 167, + 167, + 166, + 125, + 167, + 500, + 125, + 167, + 333, + 125, + 458, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 333, + 84, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 84, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 42, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 83, + 42, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 84, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 84, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 209, + 125, + 125, + 208, + 208, + 125, + 125, + 250, + 125, + 167, + 208, + 167, + 167, + 166, + 834, + 125, + 125, + 166, + 167, + 208, + 125, + 167, + 125, + 167, + 166, + 167, + 83, + 209, + 208, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 375, + 42, + 125, + 125, + 125, + 125, + 667, + 41, + 42, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 292, + 625, + 875, + 416, + 875, + 334, + 166, + 375, + 334, + 333, + 208, + 250, + 375, + 417, + 458, + 250, + 917, + 3000, + 125, + 167, + 125, + 625, + 500, + 500, + 1125, + 416, + 667, + 625, + 375, + 208, + 167, + 250, + 167, + 291, + 167, + 125, + 208, + 250, + 209, + 333, + 167, + 125, + 166, + 167, + 250, + 125, + 708, + 250, + 167, + 292, + 333, + 250, + 125, + 500, + 250, + 625, + 208, + 167, + 167, + 125, + 208, + 333, + 209, + 125, + 333, + 208, + 209, + 208, + 500, + 417, + 208, + 208, + 334, + 250, + 458, + 167, + 166, + 209, + 166, + 459, + 458, + 167, + 625, + 458, + 250, + 250, + 167, + 166, + 167, + 375, + 125, + 208, + 250, + 250, + 125, + 167, + 167, + 250, + 375, + 166, + 167, + 167, + 125, + 208, + 208, + 209, + 208, + 458, + 542, + 125, + 167, + 208, + 167, + 166, + 250, + 125, + 125, + 125, + 167, + 167, + 166, + 209, + 166, + 167, + 125, + 167, + 166, + 417, + 167, + 291, + 125, + 125, + 250, + 250, + 125, + 250, + 250, + 167, + 333, + 125, + 167, + 125, + 292, + 375, + 125, + 250, + 458, + 250, + 375, + 167, + 291, + 125, + 292, + 333, + 250, + 292, + 167, + 375, + 666, + 167, + 125, + 125, + 375, + 167, + 291, + 167, + 250, + 167, + 208, + 250, + 167, + 416, + 167, + 333, + 209, + 166, + 125, + 209, + 125, + 250, + 125, + 583, + 167, + 250, + 250, + 166, + 209, + 166, + 125, + 125, + 167, + 208, + 167, + 208, + 209, + 208, + 417, + 583, + 167, + 208, + 250, + 292, + 166, + 209, + 166, + 167, + 208, + 375, + 167, + 208, + 417, + 167, + 208, + 167, + 166, + 375, + 209, + 208, + 250, + 292, + 1625, + 166, + 1250, + 250, + 584, + 333, + 292, + 541, + 459, + 250, + 166, + 500, + 417, + 333, + 125, + 1167, + 208, + 375, + 375, + 292, + 333, + 292, + 333, + 250, + 250, + 375, + 292, + 333, + 209, + 166, + 167, + 125, + 208, + 250, + 209, + 166, + 167, + 125, + 125, + 167, + 333, + 167, + 125, + 166, + 209, + 166, + 167, + 292, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 250, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 291, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 208, + 208, + 209, + 125, + 250, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 209, + 500, + 125, + 166, + 167, + 125, + 167, + 208, + 125, + 167, + 125, + 166, + 125, + 334, + 41, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 208, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 83, + 167, + 208, + 125, + 208, + 125, + 167, + 250, + 83, + 167, + 167, + 125, + 166, + 125, + 292, + 750, + 167, + 125, + 166, + 125, + 209, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 84, + 125, + 125, + 208, + 167, + 166, + 292, + 125, + 167, + 166, + 167, + 167, + 208, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 250, + 417, + 167, + 166, + 167, + 125, + 167, + 291, + 167, + 167, + 125, + 125, + 208, + 208, + 84, + 166, + 125, + 125, + 250, + 167, + 125, + 83, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 208, + 167, + 250, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 250, + 125, + 166, + 125, + 167, + 167, + 125, + 208, + 917, + 708, + 167, + 208, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 209, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 250, + 209, + 166, + 125, + 209, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 167, + 333, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 83, + 0, + 84, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 208, + 209, + 125, + 166, + 167, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 208, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 125, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 83, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 208, + 209, + 208, + 125, + 458, + 125, + 167, + 125, + 167, + 208, + 167, + 166, + 167, + 167, + 83, + 167, + 125, + 125, + 166, + 167, + 208, + 125, + 125, + 209, + 250, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 209, + 166, + 209, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 1417, + 250, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 291, + 125, + 125, + 125, + 375, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 334, + 83, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 333, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 2500, + 2417, + 5416, + 1709, + 250, + 375, + 166, + 167, + 542, + 166, + 500, + 125, + 292, + 625, + 125, + 292, + 541, + 3084, + 416, + 1167, + 417, + 1750, + 125, + 375, + 666, + 375, + 417, + 375, + 167, + 166, + 542, + 250, + 125, + 375, + 167, + 583, + 125, + 375, + 167, + 208, + 167, + 125, + 125, + 416, + 167, + 542, + 541, + 250, + 1084, + 166, + 459, + 458, + 375, + 375, + 208, + 209, + 375, + 166, + 292, + 292, + 10583, + 17125, + 167, + 208, + 125, + 125, + 2042, + 166, + 125, + 4542, + 417, + 208, + 1042, + 125, + 125, + 291, + 792, + 792, + 333, + 792, + 125, + 1625, + 1916, + 417, + 208, + 2542, + 333, + 2959, + 416, + 417, + 333, + 709, + 250, + 416, + 209, + 291, + 167, + 83, + 417, + 292, + 6500, + 875, + 625, + 166, + 167, + 500, + 167, + 208, + 125, + 208, + 125, + 167, + 500, + 125, + 250, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 209, + 166, + 1375, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 459, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 5041, + 13292, + 9292, + 541, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 208, + 125, + 208, + 292, + 1083, + 209, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 84, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 84, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 458, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 209, + 125, + 166, + 167, + 292, + 541, + 125, + 167, + 167, + 208, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 209, + 83, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 208, + 167, + 125, + 167, + 125, + 291, + 125, + 167, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 83, + 125, + 125, + 167, + 125, + 167, + 250, + 166, + 125, + 125, + 250, + 167, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 208, + 167, + 167, + 125, + 166, + 167, + 250, + 167, + 375, + 166, + 125, + 167, + 208, + 167, + 208, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 209, + 125, + 125, + 125, + 125, + 125, + 208, + 208, + 125, + 84, + 166, + 167, + 125, + 208, + 209, + 166, + 125, + 125, + 167, + 125, + 125, + 250, + 167, + 208, + 250, + 208, + 209, + 125, + 125, + 291, + 250, + 167, + 167, + 125, + 125, + 125, + 208, + 167, + 208, + 292, + 166, + 167, + 333, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 83, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 292, + 42, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 208, + 167, + 167, + 166, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 208, + 125, + 125, + 209, + 208, + 125, + 125, + 292, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 83, + 125, + 125, + 167, + 291, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 83, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 208, + 167, + 125, + 208, + 167, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 209, + 208, + 167, + 125, + 208, + 125, + 167, + 166, + 167, + 167, + 125, + 333, + 125, + 167, + 166, + 125, + 84, + 166, + 167, + 125, + 167, + 166, + 750, + 209, + 250, + 166, + 209, + 125, + 166, + 167, + 208, + 125, + 167, + 167, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 83, + 167, + 167, + 125, + 125, + 250, + 125, + 125, + 1500, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 209, + 208, + 125, + 167, + 125, + 166, + 209, + 166, + 250, + 209, + 0, + 166, + 125, + 125, + 167, + 167, + 166, + 2917, + 1167, + 500, + 458, + 167, + 750, + 791, + 5000, + 1125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 583, + 750, + 250, + 125, + 167, + 166, + 125, + 417, + 542, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 500, + 125, + 125, + 167, + 167, + 1083, + 458, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 250, + 208, + 167, + 417, + 416, + 209, + 125, + 375, + 208, + 167, + 166, + 500, + 417, + 167, + 166, + 167, + 3458, + 334, + 166, + 1334, + 4250, + 24458, + 36875, + 2083, + 25584, + 17625, + 125, + 166, + 250, + 167, + 167, + 208, + 250, + 42, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 1083, + 209, + 166, + 167, + 167, + 125, + 83, + 167, + 583, + 167, + 166, + 125, + 834, + 125, + 125, + 166, + 125, + 167, + 25292, + 4583, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 208, + 250, + 167, + 125, + 167, + 166, + 125, + 84, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 334, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 541, + 167, + 167, + 166, + 125, + 125, + 209, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 84, + 166, + 125, + 167, + 125, + 167, + 83, + 167, + 208, + 125, + 208, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 250, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 292, + 250, + 167, + 250, + 125, + 125, + 125, + 125, + 250, + 166, + 167, + 167, + 125, + 125, + 125, + 250, + 125, + 208, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 209, + 166, + 125, + 167, + 167, + 83, + 167, + 166, + 209, + 166, + 125, + 209, + 458, + 167, + 166, + 84, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 125, + 209, + 166, + 167, + 125, + 167, + 166, + 209, + 83, + 125, + 167, + 166, + 84, + 125, + 125, + 125, + 125, + 291, + 167, + 167, + 125, + 125, + 208, + 208, + 125, + 209, + 125, + 208, + 250, + 125, + 208, + 125, + 167, + 208, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 250, + 292, + 125, + 166, + 167, + 125, + 250, + 250, + 167, + 166, + 125, + 125, + 250, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 333, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 209, + 250, + 125, + 166, + 125, + 209, + 125, + 125, + 166, + 167, + 125, + 208, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 208, + 500, + 292, + 166, + 250, + 167, + 125, + 125, + 208, + 167, + 250, + 167, + 333, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 291, + 167, + 167, + 125, + 208, + 167, + 291, + 167, + 167, + 125, + 125, + 208, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 208, + 167, + 333, + 125, + 125, + 209, + 166, + 125, + 209, + 208, + 208, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 83, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 209, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 250, + 166, + 375, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 83, + 209, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 0, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 250, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 208, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 83, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 250, + 208, + 125, + 167, + 167, + 208, + 500, + 1125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 208, + 375, + 84, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 167, + 83, + 209, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 208, + 458, + 0, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 125, + 167, + 42, + 166, + 84, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 208, + 167, + 208, + 125, + 84, + 125, + 166, + 334, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 209, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 208, + 6625, + 30750, + 13708, + 4500, + 1375, + 2875, + 125, + 4584, + 1916, + 3042, + 25875, + 3208, + 7000, + 2417, + 3083, + 2375, + 209, + 250, + 0, + 708, + 167, + 333, + 125, + 292, + 250, + 291, + 1500, + 292, + 1208, + 1709, + 250, + 666, + 500, + 792, + 167, + 500, + 500, + 41, + 542, + 542, + 166, + 667, + 167, + 166, + 542, + 208, + 24417, + 125, + 417, + 750, + 2125, + 125, + 166, + 1167, + 167, + 208, + 292, + 166, + 209, + 125, + 125, + 166, + 250, + 125, + 167, + 167, + 208, + 167, + 166, + 167, + 167, + 166, + 167, + 250, + 125, + 292, + 208, + 583, + 167, + 208, + 500, + 250, + 167, + 250, + 167, + 125, + 166, + 125, + 292, + 167, + 250, + 208, + 375, + 167, + 125, + 208, + 125, + 167, + 208, + 417, + 250, + 208, + 458, + 167, + 167, + 250, + 208, + 125, + 458, + 417, + 167, + 0, + 500, + 458, + 333, + 375, + 125, + 125, + 334, + 833, + 208, + 167, + 250, + 167, + 333, + 458, + 167, + 83, + 167, + 167, + 166, + 209, + 208, + 208, + 125, + 209, + 208, + 167, + 208, + 208, + 167, + 167, + 166, + 292, + 208, + 167, + 792, + 166, + 417, + 208, + 125, + 292, + 125, + 167, + 166, + 334, + 166, + 334, + 166, + 417, + 125, + 125, + 167, + 208, + 250, + 250, + 167, + 166, + 167, + 208, + 167, + 292, + 208, + 208, + 125, + 209, + 125, + 250, + 166, + 250, + 167, + 333, + 167, + 125, + 333, + 209, + 208, + 333, + 209, + 708, + 125, + 500, + 292, + 291, + 459, + 166, + 417, + 250, + 125, + 208, + 167, + 208, + 125, + 250, + 167, + 333, + 375, + 1292, + 250, + 167, + 291, + 417, + 792, + 291, + 167, + 500, + 375, + 250, + 208, + 334, + 291, + 584, + 166, + 167, + 583, + 584, + 458, + 1250, + 1083, + 1584, + 250, + 375, + 208, + 250, + 208, + 167, + 417, + 166, + 292, + 417, + 1041, + 250, + 584, + 208, + 375, + 208, + 1000, + 292, + 208, + 209, + 708, + 542, + 500, + 291, + 209, + 458, + 500, + 1083, + 84, + 208, + 583, + 209, + 166, + 209, + 166, + 209, + 166, + 125, + 250, + 209, + 125, + 166, + 167, + 167, + 583, + 167, + 291, + 250, + 209, + 208, + 167, + 208, + 333, + 125, + 250, + 167, + 167, + 125, + 375, + 125, + 208, + 125, + 167, + 416, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 209, + 125, + 166, + 125, + 209, + 125, + 166, + 125, + 125, + 292, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 250, + 125, + 375, + 208, + 125, + 125, + 125, + 125, + 250, + 125, + 167, + 208, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 250, + 125, + 208, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 208, + 167, + 208, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 250, + 167, + 417, + 125, + 166, + 709, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 250, + 125, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 83, + 167, + 167, + 166, + 167, + 208, + 167, + 125, + 125, + 125, + 167, + 208, + 167, + 583, + 167, + 125, + 166, + 167, + 125, + 1167, + 166, + 167, + 208, + 250, + 375, + 125, + 167, + 125, + 1083, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 209, + 416, + 209, + 708, + 125, + 500, + 917, + 125, + 125, + 125, + 166, + 1167, + 167, + 208, + 83, + 84, + 83, + 292, + 125, + 416, + 125, + 334, + 291, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 208, + 167, + 583, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 209, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 209, + 166, + 167, + 167, + 83, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 208, + 167, + 208, + 167, + 167, + 166, + 125, + 209, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 208, + 125, + 375, + 292, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 375, + 42, + 125, + 125, + 125, + 167, + 166, + 209, + 125, + 125, + 208, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 209, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 167, + 167, + 125, + 208, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 209, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 959, + 125, + 125, + 166, + 167, + 333, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 250, + 125, + 167, + 167, + 166, + 167, + 125, + 208, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 208, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 1458, + 125, + 125, + 125, + 167, + 125, + 250, + 166, + 209, + 166, + 209, + 291, + 125, + 209, + 166, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 250, + 209, + 125, + 250, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 166, + 209, + 250, + 166, + 125, + 209, + 41, + 84, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 208, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 333, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 333, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 375, + 0, + 166, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 209, + 166, + 167, + 125, + 167, + 208, + 125, + 167, + 208, + 208, + 167, + 208, + 709, + 333, + 125, + 250, + 167, + 166, + 167, + 167, + 166, + 84, + 208, + 167, + 791, + 209, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 167, + 208, + 208, + 209, + 208, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 125, + 84, + 208, + 167, + 125, + 166, + 167, + 958, + 209, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 333, + 167, + 583, + 125, + 167, + 167, + 166, + 84, + 333, + 125, + 125, + 125, + 250, + 167, + 166, + 334, + 291, + 209, + 416, + 125, + 209, + 166, + 334, + 208, + 83, + 209, + 166, + 167, + 167, + 208, + 125, + 167, + 125, + 125, + 166, + 209, + 208, + 208, + 8750, + 125, + 125, + 542, + 125, + 125, + 167, + 166, + 125, + 167, + 208, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 666, + 167, + 167, + 333, + 167, + 166, + 209, + 208, + 167, + 125, + 208, + 292, + 166, + 292, + 167, + 125, + 166, + 334, + 125, + 83, + 167, + 1208, + 167, + 2583, + 2958, + 1042, + 1375, + 1333, + 542, + 1208, + 750, + 1167, + 833, + 2417, + 1083, + 2667, + 750, + 375, + 1292, + 333, + 458, + 417, + 250, + 500, + 417, + 625, + 791, + 125, + 209, + 416, + 375, + 209, + 333, + 167, + 208, + 542, + 375, + 208, + 667, + 458, + 208, + 167, + 125, + 333, + 334, + 333, + 167, + 208, + 458, + 209, + 458, + 417, + 125, + 291, + 167, + 292, + 1458, + 875, + 292, + 666, + 417, + 292, + 125, + 416, + 167, + 375, + 1250, + 958, + 542, + 458, + 417, + 1500, + 667, + 333, + 333, + 1209, + 44416, + 31000, + 292, + 1333, + 959, + 1666, + 2875, + 375, + 1292, + 4917, + 833, + 292, + 5000, + 708, + 500, + 500, + 292, + 583, + 292, + 333, + 2042, + 250, + 500, + 1125, + 166, + 125, + 1625, + 917, + 375, + 208, + 375, + 375, + 84, + 166, + 167, + 208, + 167, + 208, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 208, + 1334, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 84, + 166, + 167, + 83, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 542, + 166, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 209, + 291, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 83, + 209, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 250, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 500, + 125, + 125, + 167, + 708, + 209, + 250, + 166, + 125, + 209, + 208, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 167, + 167, + 166, + 250, + 125, + 125, + 167, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 541, + 1667, + 2917, + 166, + 250, + 209, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 167, + 166, + 167, + 125, + 167, + 166, + 792, + 125, + 250, + 125, + 2833, + 209, + 125, + 166, + 167, + 125, + 125, + 125, + 208, + 167, + 250, + 208, + 625, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 41, + 1042, + 125, + 542, + 166, + 14000, + 11125, + 167, + 167, + 125, + 166, + 84, + 166, + 125, + 209, + 125, + 166, + 292, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 250, + 291, + 167, + 125, + 375, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 250, + 125, + 125, + 166, + 167, + 208, + 167, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 84, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 333, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 250, + 167, + 208, + 125, + 125, + 167, + 417, + 125, + 166, + 500, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 167, + 83, + 167, + 166, + 167, + 83, + 125, + 209, + 125, + 125, + 166, + 84, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 1084, + 125, + 250, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 167, + 166, + 250, + 125, + 167, + 125, + 167, + 208, + 167, + 583, + 917, + 250, + 166, + 209, + 125, + 166, + 84, + 125, + 958, + 792, + 250, + 1208, + 1583, + 209, + 750, + 375, + 416, + 542, + 500, + 1875, + 750, + 417, + 583, + 917, + 458, + 458, + 209, + 375, + 416, + 209, + 375, + 1333, + 542, + 166, + 375, + 167, + 708, + 2417, + 292, + 208, + 250, + 208, + 167, + 208, + 167, + 167, + 125, + 1791, + 459, + 1250, + 1500, + 1125, + 250, + 125, + 250, + 416, + 209, + 208, + 333, + 125, + 334, + 166, + 250, + 667, + 625, + 208, + 167, + 500, + 167, + 166, + 167, + 208, + 167, + 333, + 334, + 166, + 167, + 167, + 708, + 917, + 375, + 125, + 291, + 167, + 208, + 167, + 125, + 167, + 208, + 167, + 166, + 250, + 167, + 208, + 209, + 208, + 208, + 250, + 375, + 375, + 125, + 167, + 583, + 209, + 125, + 791, + 750, + 167, + 208, + 750, + 167, + 167, + 291, + 375, + 334, + 416, + 250, + 209, + 1083, + 625, + 375, + 208, + 125, + 167, + 292, + 166, + 667, + 250, + 208, + 209, + 166, + 209, + 208, + 167, + 166, + 209, + 125, + 333, + 167, + 416, + 167, + 167, + 125, + 333, + 458, + 250, + 209, + 125, + 500, + 666, + 209, + 375, + 375, + 166, + 167, + 292, + 1000, + 250, + 333, + 417, + 875, + 291, + 417, + 375, + 833, + 167, + 125, + 417, + 666, + 1084, + 458, + 292, + 166, + 167, + 250, + 375, + 458, + 292, + 208, + 250, + 292, + 208, + 209, + 166, + 375, + 292, + 208, + 375, + 209, + 791, + 542, + 292, + 166, + 167, + 1375, + 167, + 208, + 917, + 166, + 500, + 292, + 250, + 500, + 208, + 459, + 291, + 125, + 250, + 209, + 208, + 167, + 125, + 166, + 167, + 208, + 250, + 167, + 167, + 333, + 292, + 208, + 875, + 208, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 250, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 208, + 125, + 208, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 208, + 417, + 167, + 83, + 125, + 125, + 375, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 208, + 125, + 125, + 167, + 375, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 208, + 125, + 417, + 1583, + 84, + 166, + 125, + 125, + 459, + 125, + 541, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 167, + 166, + 167, + 125, + 167, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 166, + 209, + 83, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 541, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 208, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 208, + 125, + 167, + 166, + 875, + 125, + 500, + 209, + 125, + 125, + 375, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 209, + 41, + 167, + 125, + 167, + 125, + 208, + 208, + 167, + 167, + 83, + 125, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 84, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 167, + 125, + 166, + 84, + 166, + 250, + 0, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 208, + 167, + 125, + 125, + 166, + 1042, + 167, + 166, + 84, + 166, + 125, + 167, + 292, + 333, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 209, + 458, + 42, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 84, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 291, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 334, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 41, + 125, + 125, + 167, + 125, + 167, + 166, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 208, + 83, + 209, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 41, + 167, + 208, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 250, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 333, + 167, + 166, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 83, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 208, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 208, + 167, + 208, + 167, + 166, + 125, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 209, + 166, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 83, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 458, + 250, + 250, + 125, + 250, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 250, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 291, + 125, + 917, + 792, + 875, + 541, + 3500, + 375, + 1042, + 375, + 125, + 167, + 458, + 125, + 333, + 209, + 375, + 250, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 292, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 292, + 167, + 458, + 4833, + 1917, + 458, + 917, + 17792, + 1666, + 250, + 6792, + 917, + 125, + 166, + 167, + 208, + 167, + 250, + 125, + 167, + 166, + 125, + 209, + 166, + 167, + 125, + 208, + 167, + 375, + 250, + 167, + 166, + 209, + 1916, + 250, + 709, + 2708, + 2708, + 459, + 5708, + 12875, + 21958, + 375, + 167, + 125, + 167, + 125, + 208, + 167, + 166, + 209, + 166, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 500, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 875, + 875, + 250, + 125, + 125, + 250, + 166, + 125, + 125, + 209, + 333, + 208, + 167, + 167, + 125, + 208, + 125, + 1000, + 667, + 250, + 791, + 84, + 2083, + 9000, + 2667, + 1833, + 5000, + 42, + 125, + 166, + 375, + 209, + 208, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 250, + 125, + 250, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 208, + 209, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 834, + 1416, + 292, + 542, + 500, + 1208, + 333, + 209, + 333, + 250, + 333, + 167, + 250, + 458, + 334, + 625, + 166, + 417, + 833, + 750, + 417, + 750, + 250, + 875, + 458, + 1125, + 709, + 458, + 167, + 166, + 875, + 125, + 584, + 1166, + 250, + 84, + 166, + 167, + 167, + 208, + 208, + 125, + 167, + 500, + 250, + 333, + 375, + 167, + 125, + 292, + 166, + 209, + 333, + 208, + 250, + 292, + 458, + 292, + 542, + 125, + 500, + 250, + 208, + 250, + 83, + 209, + 333, + 167, + 83, + 125, + 208, + 209, + 333, + 167, + 458, + 208, + 500, + 125, + 167, + 708, + 125, + 250, + 334, + 291, + 125, + 292, + 292, + 291, + 209, + 83, + 208, + 459, + 166, + 167, + 167, + 500, + 500, + 208, + 375, + 125, + 125, + 333, + 625, + 334, + 1833, + 1000, + 167, + 125, + 833, + 500, + 917, + 666, + 250, + 834, + 208, + 292, + 291, + 167, + 125, + 1167, + 750, + 750, + 708, + 333, + 250, + 209, + 333, + 167, + 250, + 208, + 167, + 125, + 166, + 250, + 459, + 250, + 375, + 208, + 167, + 250, + 208, + 292, + 291, + 167, + 167, + 166, + 167, + 417, + 166, + 167, + 250, + 292, + 416, + 334, + 166, + 625, + 250, + 250, + 167, + 292, + 166, + 542, + 458, + 209, + 208, + 167, + 291, + 167, + 208, + 167, + 125, + 167, + 166, + 167, + 250, + 167, + 208, + 208, + 209, + 125, + 250, + 1041, + 250, + 209, + 291, + 167, + 208, + 167, + 208, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 208, + 333, + 209, + 250, + 250, + 166, + 125, + 167, + 250, + 167, + 166, + 167, + 167, + 333, + 208, + 209, + 166, + 167, + 125, + 125, + 208, + 292, + 542, + 125, + 333, + 167, + 250, + 458, + 292, + 291, + 125, + 209, + 125, + 208, + 292, + 166, + 167, + 250, + 167, + 333, + 167, + 125, + 166, + 167, + 208, + 167, + 125, + 208, + 334, + 208, + 167, + 166, + 167, + 208, + 167, + 167, + 166, + 209, + 166, + 667, + 792, + 83, + 0, + 125, + 125, + 250, + 208, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 166, + 84, + 166, + 125, + 209, + 166, + 125, + 167, + 208, + 209, + 125, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 83, + 208, + 125, + 167, + 208, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 250, + 125, + 208, + 125, + 167, + 375, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 209, + 166, + 125, + 209, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 208, + 125, + 500, + 125, + 375, + 292, + 166, + 167, + 167, + 125, + 166, + 209, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 166, + 125, + 167, + 292, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 208, + 208, + 334, + 125, + 166, + 84, + 208, + 83, + 125, + 167, + 125, + 125, + 167, + 125, + 250, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 209, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 583, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 208, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 209, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 42, + 167, + 125, + 333, + 83, + 209, + 125, + 125, + 166, + 167, + 125, + 125, + 208, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 167, + 125, + 208, + 208, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 334, + 166, + 167, + 125, + 125, + 125, + 250, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 83, + 84, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 292, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 333, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 84, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 83, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 292, + 125, + 291, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 83, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 208, + 167, + 83, + 208, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 83, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 83, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 541, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 209, + 83, + 167, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 83, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 208, + 167, + 125, + 208, + 167, + 167, + 125, + 208, + 208, + 250, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 208, + 625, + 250, + 167, + 166, + 209, + 125, + 166, + 125, + 125, + 250, + 125, + 125, + 125, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 250, + 125, + 125, + 166, + 167, + 208, + 167, + 167, + 166, + 125, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 250, + 125, + 209, + 208, + 125, + 458, + 167, + 125, + 167, + 208, + 208, + 167, + 250, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 125, + 125, + 83, + 167, + 125, + 250, + 83, + 167, + 167, + 208, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 250, + 167, + 208, + 167, + 166, + 209, + 166, + 209, + 166, + 209, + 250, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 416, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 250, + 208, + 167, + 42, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 84, + 166, + 167, + 83, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 3042, + 1708, + 125, + 3334, + 15291, + 750, + 334, + 1916, + 167, + 625, + 458, + 167, + 250, + 375, + 1625, + 292, + 1958, + 1083, + 4042, + 167, + 250, + 541, + 875, + 167, + 167, + 166, + 542, + 125, + 417, + 333, + 542, + 458, + 375, + 375, + 292, + 166, + 209, + 250, + 208, + 250, + 208, + 167, + 792, + 375, + 208, + 417, + 291, + 167, + 542, + 708, + 625, + 500, + 3250, + 1667, + 166, + 9375, + 2250, + 250, + 417, + 1167, + 125, + 250, + 583, + 2917, + 791, + 209, + 166, + 125, + 209, + 208, + 1167, + 208, + 208, + 625, + 209, + 708, + 3500, + 16833, + 1667, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 209, + 125, + 125, + 208, + 167, + 125, + 791, + 167, + 333, + 3375, + 209, + 166, + 167, + 125, + 125, + 708, + 375, + 167, + 167, + 125, + 166, + 167, + 208, + 125, + 209, + 8083, + 11917, + 1000, + 166, + 209, + 500, + 166, + 209, + 375, + 125, + 125, + 166, + 209, + 166, + 125, + 125, + 250, + 167, + 167, + 166, + 125, + 125, + 167, + 250, + 83, + 167, + 125, + 167, + 125, + 250, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 292, + 166, + 667, + 958, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 209, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 209, + 1250, + 541, + 1459, + 250, + 416, + 167, + 250, + 583, + 125, + 167, + 292, + 250, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 208, + 167, + 208, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 166, + 167, + 208, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 250, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 84, + 166, + 167, + 167, + 166, + 250, + 125, + 167, + 125, + 208, + 125, + 167, + 167, + 166, + 84, + 166, + 167, + 125, + 83, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 250, + 208, + 83, + 334, + 41, + 167, + 958, + 292, + 42, + 1625, + 250, + 166, + 42, + 208, + 209, + 291, + 1417, + 1583, + 1542, + 208, + 125, + 250, + 125, + 250, + 209, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 250, + 167, + 167, + 166, + 167, + 458, + 209, + 166, + 167, + 167, + 250, + 166, + 209, + 333, + 83, + 167, + 167, + 125, + 333, + 1250, + 292, + 2208, + 292, + 250, + 166, + 334, + 750, + 333, + 333, + 167, + 167, + 250, + 375, + 125, + 166, + 167, + 292, + 1708, + 417, + 1208, + 583, + 625, + 1000, + 209, + 166, + 167, + 1167, + 666, + 8334, + 666, + 959, + 416, + 459, + 416, + 584, + 375, + 250, + 500, + 166, + 1250, + 417, + 875, + 208, + 167, + 333, + 125, + 250, + 84, + 375, + 375, + 916, + 1042, + 375, + 1708, + 2584, + 125, + 125, + 625, + 250, + 500, + 250, + 166, + 167, + 167, + 166, + 125, + 167, + 208, + 167, + 167, + 250, + 250, + 166, + 209, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 83, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 250, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 208, + 209, + 166, + 167, + 250, + 208, + 209, + 125, + 125, + 125, + 166, + 167, + 167, + 208, + 167, + 83, + 167, + 125, + 208, + 250, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 83, + 167, + 167, + 166, + 125, + 209, + 416, + 334, + 166, + 209, + 125, + 208, + 167, + 125, + 166, + 209, + 125, + 208, + 167, + 125, + 166, + 167, + 167, + 250, + 125, + 291, + 375, + 750, + 125, + 2167, + 125, + 375, + 3750, + 2458, + 792, + 292, + 458, + 1750, + 208, + 167, + 250, + 125, + 292, + 125, + 166, + 167, + 167, + 208, + 167, + 250, + 166, + 209, + 166, + 167, + 208, + 125, + 125, + 167, + 250, + 167, + 250, + 166, + 334, + 541, + 667, + 292, + 125, + 375, + 250, + 1666, + 3834, + 166, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 292, + 42, + 125, + 166, + 167, + 28542, + 24083, + 27500, + 167, + 166, + 167, + 1000, + 125, + 167, + 125, + 166, + 125, + 250, + 250, + 209, + 166, + 167, + 208, + 167, + 1000, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 750, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 500, + 208, + 167, + 166, + 209, + 41, + 167, + 208, + 125, + 167, + 167, + 166, + 167, + 83, + 8084, + 10000, + 1333, + 208, + 167, + 792, + 83, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 83, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 375, + 167, + 125, + 166, + 167, + 250, + 208, + 167, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 208, + 167, + 167, + 208, + 125, + 292, + 125, + 125, + 125, + 166, + 125, + 209, + 458, + 167, + 166, + 125, + 292, + 167, + 166, + 209, + 1166, + 167, + 583, + 750, + 1584, + 1041, + 875, + 167, + 125, + 458, + 459, + 666, + 1000, + 459, + 625, + 750, + 83, + 1125, + 167, + 458, + 500, + 167, + 1250, + 875, + 333, + 667, + 375, + 125, + 333, + 792, + 583, + 1333, + 292, + 208, + 459, + 333, + 167, + 208, + 208, + 167, + 125, + 125, + 1000, + 125, + 167, + 166, + 167, + 375, + 167, + 291, + 125, + 167, + 208, + 250, + 167, + 167, + 125, + 166, + 125, + 209, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 209, + 166, + 292, + 167, + 166, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 209, + 125, + 416, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 375, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 166, + 125, + 125, + 125, + 167, + 250, + 167, + 166, + 167, + 125, + 125, + 167, + 166, + 209, + 125, + 125, + 416, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 209, + 125, + 208, + 167, + 125, + 166, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 125, + 250, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 250, + 125, + 125, + 458, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 292, + 417, + 291, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 250, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 250, + 125, + 125, + 209, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 166, + 209, + 166, + 125, + 167, + 125, + 417, + 166, + 209, + 125, + 125, + 166, + 167, + 125, + 167, + 208, + 125, + 167, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 209, + 166, + 167, + 167, + 125, + 125, + 125, + 583, + 208, + 167, + 750, + 125, + 167, + 250, + 166, + 334, + 166, + 334, + 125, + 125, + 125, + 166, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 209, + 291, + 209, + 166, + 167, + 125, + 167, + 2375, + 166, + 209, + 166, + 209, + 166, + 167, + 125, + 125, + 333, + 167, + 250, + 167, + 166, + 167, + 208, + 334, + 291, + 250, + 834, + 166, + 209, + 208, + 167, + 333, + 208, + 167, + 167, + 125, + 208, + 125, + 333, + 167, + 125, + 208, + 625, + 2459, + 166, + 125, + 167, + 167, + 416, + 125, + 125, + 125, + 209, + 750, + 208, + 167, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 791, + 167, + 167, + 166, + 125, + 167, + 167, + 291, + 125, + 167, + 125, + 167, + 291, + 125, + 292, + 167, + 125, + 166, + 167, + 83, + 125, + 167, + 250, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 292, + 125, + 208, + 167, + 83, + 167, + 125, + 208, + 208, + 167, + 125, + 208, + 125, + 209, + 333, + 250, + 125, + 208, + 209, + 166, + 167, + 125, + 250, + 167, + 125, + 208, + 167, + 208, + 125, + 167, + 166, + 209, + 166, + 125, + 167, + 208, + 125, + 209, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 291, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 209, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 916, + 292, + 125, + 292, + 166, + 167, + 167, + 166, + 167, + 250, + 83, + 250, + 167, + 500, + 167, + 166, + 209, + 125, + 166, + 167, + 208, + 167, + 125, + 167, + 125, + 166, + 542, + 167, + 166, + 625, + 209, + 166, + 167, + 125, + 167, + 166, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 208, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 209, + 250, + 125, + 166, + 125, + 3250, + 125, + 209, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 250, + 167, + 375, + 167, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 125, + 166, + 209, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 41, + 84, + 125, + 208, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 208, + 167, + 167, + 125, + 166, + 125, + 209, + 125, + 208, + 83, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 208, + 292, + 166, + 84, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 250, + 959, + 291, + 167, + 167, + 875, + 166, + 167, + 167, + 166, + 167, + 125, + 208, + 125, + 167, + 167, + 250, + 208, + 167, + 166, + 84, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 209, + 166, + 167, + 125, + 167, + 375, + 125, + 166, + 167, + 208, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 209, + 250, + 166, + 250, + 125, + 209, + 125, + 125, + 166, + 167, + 250, + 125, + 125, + 250, + 125, + 167, + 125, + 208, + 208, + 334, + 166, + 125, + 125, + 167, + 208, + 209, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 208, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 84, + 166, + 167, + 125, + 125, + 167, + 166, + 84, + 166, + 292, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 1167, + 333, + 458, + 125, + 125, + 125, + 375, + 292, + 583, + 1584, + 416, + 584, + 125, + 375, + 125, + 208, + 125, + 167, + 166, + 417, + 167, + 166, + 125, + 209, + 166, + 125, + 125, + 209, + 166, + 167, + 167, + 125, + 166, + 167, + 583, + 209, + 166, + 125, + 334, + 166, + 125, + 250, + 250, + 125, + 209, + 125, + 166, + 167, + 125, + 250, + 167, + 125, + 166, + 209, + 125, + 166, + 167, + 208, + 125, + 167, + 125, + 208, + 167, + 167, + 125, + 166, + 250, + 167, + 167, + 208, + 167, + 125, + 166, + 125, + 167, + 167, + 83, + 125, + 167, + 208, + 167, + 125, + 125, + 250, + 83, + 208, + 167, + 167, + 208, + 167, + 250, + 208, + 167, + 125, + 291, + 250, + 375, + 125, + 167, + 167, + 166, + 250, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 333, + 125, + 208, + 167, + 125, + 125, + 167, + 208, + 208, + 125, + 500, + 125, + 167, + 208, + 917, + 208, + 209, + 166, + 125, + 209, + 125, + 166, + 125, + 292, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 208, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 250, + 125, + 167, + 208, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 209, + 166, + 125, + 167, + 83, + 125, + 250, + 209, + 125, + 208, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 209, + 166, + 167, + 250, + 167, + 166, + 125, + 209, + 166, + 209, + 166, + 125, + 125, + 167, + 208, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 167, + 250, + 167, + 166, + 167, + 125, + 208, + 167, + 167, + 166, + 209, + 125, + 166, + 209, + 125, + 125, + 250, + 208, + 125, + 167, + 125, + 166, + 209, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 209, + 166, + 167, + 167, + 208, + 167, + 166, + 167, + 167, + 166, + 292, + 125, + 250, + 208, + 209, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 208, + 208, + 125, + 209, + 125, + 166, + 125, + 167, + 208, + 209, + 166, + 125, + 167, + 208, + 209, + 166, + 167, + 125, + 208, + 167, + 167, + 541, + 209, + 166, + 167, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 208, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 208, + 125, + 208, + 167, + 125, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 208, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 209, + 166, + 209, + 166, + 125, + 167, + 125, + 167, + 208, + 250, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 375, + 167, + 208, + 125, + 209, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 15583, + 35334, + 13916, + 125, + 250, + 334, + 208, + 208, + 125, + 292, + 208, + 459, + 125, + 125, + 166, + 125, + 209, + 166, + 125, + 250, + 125, + 167, + 417, + 166, + 125, + 167, + 167, + 125, + 125, + 583, + 125, + 125, + 167, + 166, + 167, + 125, + 375, + 42, + 125, + 166, + 167, + 125, + 167, + 166, + 1292, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 2208, + 10542, + 2167, + 3541, + 250, + 1292, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 83, + 125, + 167, + 83, + 84, + 125, + 166, + 167, + 208, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 875, + 167, + 125, + 166, + 3167, + 333, + 292, + 625, + 917, + 2500, + 666, + 1292, + 167, + 3083, + 792, + 250, + 1083, + 1333, + 167, + 2500, + 125, + 208, + 125, + 417, + 167, + 375, + 458, + 125, + 208, + 167, + 708, + 292, + 250, + 167, + 166, + 334, + 708, + 208, + 792, + 625, + 667, + 416, + 459, + 291, + 167, + 292, + 250, + 125, + 208, + 458, + 209, + 166, + 209, + 166, + 167, + 125, + 208, + 500, + 209, + 291, + 209, + 291, + 542, + 292, + 166, + 709, + 416, + 459, + 125, + 166, + 1000, + 334, + 250, + 125, + 125, + 625, + 166, + 125, + 459, + 125, + 500, + 250, + 166, + 209, + 250, + 250, + 1208, + 708, + 459, + 583, + 333, + 209, + 166, + 209, + 1208, + 167, + 208, + 500, + 167, + 166, + 250, + 167, + 542, + 166, + 375, + 125, + 167, + 542, + 250, + 166, + 1792, + 375, + 250, + 208, + 125, + 292, + 542, + 833, + 667, + 1291, + 375, + 250, + 209, + 416, + 1042, + 167, + 333, + 500, + 208, + 167, + 125, + 292, + 166, + 167, + 417, + 333, + 375, + 125, + 167, + 166, + 292, + 167, + 375, + 208, + 458, + 167, + 333, + 84, + 416, + 167, + 208, + 167, + 250, + 333, + 125, + 167, + 208, + 167, + 375, + 250, + 208, + 125, + 125, + 125, + 334, + 208, + 167, + 291, + 125, + 167, + 500, + 167, + 208, + 333, + 167, + 167, + 125, + 208, + 125, + 208, + 125, + 167, + 125, + 167, + 375, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 167, + 166, + 209, + 125, + 125, + 750, + 125, + 791, + 500, + 209, + 166, + 250, + 209, + 166, + 209, + 166, + 209, + 125, + 166, + 209, + 333, + 1208, + 417, + 167, + 208, + 125, + 167, + 500, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 250, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 250, + 166, + 167, + 125, + 250, + 167, + 208, + 125, + 500, + 375, + 292, + 125, + 125, + 166, + 167, + 83, + 125, + 167, + 333, + 167, + 125, + 208, + 375, + 250, + 209, + 291, + 167, + 208, + 209, + 125, + 208, + 333, + 167, + 250, + 292, + 541, + 709, + 208, + 125, + 125, + 167, + 166, + 209, + 125, + 208, + 125, + 208, + 125, + 125, + 167, + 167, + 208, + 167, + 166, + 125, + 125, + 167, + 208, + 125, + 125, + 209, + 208, + 125, + 167, + 125, + 250, + 125, + 166, + 125, + 84, + 291, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 291, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 250, + 167, + 125, + 125, + 125, + 166, + 125, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 167, + 166, + 125, + 209, + 125, + 166, + 125, + 167, + 167, + 166, + 209, + 166, + 125, + 84, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 208, + 167, + 125, + 208, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 208, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 83, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 166, + 167, + 167, + 416, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 83, + 208, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 167, + 250, + 250, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 208, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 208, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 208, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 166, + 167, + 125, + 125, + 167, + 83, + 83, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 83, + 208, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 167, + 250, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 291, + 84, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 250, + 0, + 84, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 84, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 84, + 83, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 166, + 250, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 250, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 84, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 83, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 375, + 42, + 166, + 167, + 250, + 333, + 42, + 42, + 166, + 167, + 167, + 125, + 166, + 209, + 125, + 250, + 166, + 125, + 167, + 125, + 167, + 208, + 125, + 208, + 167, + 167, + 166, + 167, + 167, + 208, + 167, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 83, + 209, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 208, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 208, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 83, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 417, + 83, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 209, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 208, + 167, + 166, + 125, + 292, + 125, + 167, + 166, + 125, + 209, + 166, + 125, + 125, + 167, + 250, + 167, + 166, + 125, + 125, + 209, + 208, + 125, + 1083, + 84, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 292, + 166, + 167, + 625, + 667, + 208, + 667, + 375, + 625, + 166, + 167, + 833, + 334, + 625, + 166, + 500, + 500, + 542, + 625, + 375, + 500, + 417, + 125, + 333, + 1083, + 292, + 167, + 166, + 334, + 166, + 250, + 375, + 167, + 208, + 209, + 416, + 167, + 333, + 125, + 750, + 167, + 250, + 1083, + 209, + 250, + 208, + 292, + 458, + 500, + 2708, + 459, + 125, + 166, + 584, + 416, + 417, + 583, + 250, + 167, + 250, + 167, + 500, + 333, + 792, + 416, + 542, + 250, + 167, + 250, + 291, + 167, + 167, + 2291, + 459, + 333, + 167, + 250, + 166, + 292, + 333, + 292, + 125, + 458, + 167, + 208, + 334, + 250, + 583, + 458, + 167, + 125, + 125, + 542, + 416, + 459, + 125, + 708, + 208, + 292, + 333, + 417, + 125, + 167, + 1083, + 1208, + 875, + 125, + 1209, + 208, + 333, + 167, + 208, + 209, + 333, + 208, + 167, + 333, + 417, + 292, + 333, + 458, + 250, + 334, + 208, + 208, + 125, + 125, + 250, + 209, + 208, + 167, + 125, + 166, + 417, + 208, + 125, + 250, + 250, + 167, + 417, + 416, + 167, + 208, + 167, + 125, + 292, + 291, + 167, + 167, + 250, + 166, + 167, + 333, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 167, + 208, + 167, + 166, + 125, + 167, + 167, + 208, + 167, + 166, + 209, + 166, + 167, + 875, + 167, + 125, + 333, + 417, + 166, + 334, + 125, + 166, + 167, + 167, + 166, + 167, + 250, + 167, + 125, + 208, + 250, + 208, + 167, + 167, + 166, + 209, + 166, + 209, + 208, + 208, + 209, + 291, + 125, + 334, + 166, + 125, + 167, + 167, + 375, + 125, + 250, + 125, + 166, + 167, + 333, + 167, + 250, + 125, + 292, + 541, + 125, + 209, + 333, + 167, + 250, + 166, + 125, + 292, + 250, + 125, + 167, + 166, + 209, + 125, + 125, + 125, + 208, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 292, + 250, + 292, + 166, + 209, + 166, + 209, + 125, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 292, + 166, + 417, + 167, + 166, + 125, + 84, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 208, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 83, + 167, + 83, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 292, + 125, + 125, + 208, + 125, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 208, + 167, + 125, + 166, + 167, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 208, + 167, + 250, + 125, + 166, + 167, + 167, + 208, + 1750, + 167, + 166, + 167, + 667, + 166, + 125, + 167, + 167, + 166, + 167, + 208, + 167, + 125, + 125, + 167, + 166, + 84, + 125, + 125, + 125, + 166, + 167, + 125, + 208, + 250, + 250, + 84, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 209, + 125, + 250, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 83, + 208, + 459, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 208, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 208, + 292, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 29584, + 1750, + 625, + 375, + 6416, + 1750, + 250, + 334, + 1750, + 2125, + 15750, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 208, + 125, + 208, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 84, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 250, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 84, + 166, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 125, + 208, + 125, + 125, + 208, + 209, + 208, + 417, + 208, + 167, + 125, + 125, + 541, + 167, + 125, + 167, + 166, + 167, + 625, + 292, + 125, + 208, + 208, + 209, + 208, + 125, + 167, + 125, + 208, + 208, + 167, + 167, + 291, + 209, + 166, + 417, + 0, + 333, + 375, + 792, + 292, + 958, + 333, + 209, + 125, + 3958, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 208, + 375, + 208, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 500, + 208, + 125, + 167, + 250, + 166, + 250, + 209, + 166, + 167, + 167, + 166, + 209, + 166, + 1417, + 125, + 167, + 166, + 125, + 167, + 167, + 250, + 250, + 125, + 166, + 125, + 167, + 167, + 208, + 8458, + 12584, + 458, + 1042, + 125, + 166, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 208, + 292, + 125, + 416, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 166, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 84, + 166, + 84, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 208, + 125, + 208, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 83, + 84, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 41, + 84, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 125, + 166, + 42, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 84, + 166, + 42, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 416, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 167, + 125, + 167, + 125, + 208, + 167, + 166, + 125, + 209, + 166, + 209, + 125, + 125, + 208, + 125, + 250, + 208, + 167, + 167, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 667, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 292, + 708, + 458, + 250, + 167, + 167, + 500, + 208, + 292, + 250, + 166, + 209, + 208, + 125, + 167, + 208, + 208, + 125, + 167, + 292, + 166, + 209, + 166, + 209, + 500, + 458, + 417, + 541, + 167, + 2000, + 500, + 167, + 333, + 1083, + 1375, + 459, + 375, + 500, + 291, + 375, + 417, + 125, + 250, + 167, + 125, + 166, + 125, + 250, + 292, + 583, + 167, + 167, + 166, + 167, + 292, + 125, + 291, + 209, + 250, + 208, + 167, + 291, + 209, + 166, + 209, + 166, + 250, + 125, + 209, + 250, + 208, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 208, + 125, + 208, + 125, + 167, + 208, + 167, + 250, + 208, + 250, + 167, + 167, + 250, + 208, + 167, + 166, + 209, + 166, + 167, + 167, + 208, + 292, + 208, + 167, + 250, + 166, + 167, + 167, + 166, + 125, + 334, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 167, + 208, + 125, + 167, + 1625, + 667, + 625, + 291, + 167, + 167, + 250, + 333, + 167, + 83, + 208, + 125, + 167, + 167, + 208, + 208, + 125, + 167, + 167, + 166, + 209, + 166, + 167, + 167, + 166, + 167, + 167, + 250, + 166, + 125, + 167, + 167, + 208, + 250, + 167, + 208, + 208, + 125, + 167, + 167, + 208, + 208, + 167, + 167, + 166, + 167, + 167, + 208, + 167, + 166, + 167, + 167, + 166, + 209, + 208, + 167, + 500, + 125, + 166, + 167, + 375, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 167, + 208, + 167, + 166, + 209, + 125, + 208, + 125, + 167, + 125, + 208, + 167, + 166, + 84, + 166, + 167, + 208, + 167, + 333, + 167, + 125, + 375, + 208, + 459, + 208, + 208, + 125, + 167, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 166, + 125, + 292, + 167, + 166, + 125, + 125, + 209, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 250, + 125, + 208, + 167, + 167, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 208, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 208, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 208, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 84, + 208, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 250, + 125, + 334, + 208, + 167, + 125, + 125, + 125, + 125, + 250, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 83, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 84, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 167, + 125, + 166, + 84, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 208, + 125, + 208, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 83, + 83, + 167, + 125, + 167, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 84, + 208, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 83, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 166, + 209, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 84, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 84, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 83, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 209, + 41, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 42, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 41, + 125, + 84, + 125, + 166, + 125, + 84, + 125, + 125, + 166, + 250, + 125, + 125, + 125, + 167, + 42, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 125, + 125, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 209, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 84, + 125, + 166, + 125, + 209, + 125, + 166, + 125, + 125, + 84, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 209, + 166, + 167, + 125, + 167, + 333, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 83, + 167, + 83, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 208, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 208, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 42, + 167, + 41, + 167, + 125, + 167, + 166, + 84, + 166, + 125, + 84, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 41, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 625, + 42, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 417, + 375, + 792, + 500, + 166, + 167, + 167, + 166, + 167, + 250, + 333, + 209, + 166, + 417, + 167, + 208, + 458, + 375, + 584, + 125, + 166, + 334, + 416, + 125, + 167, + 292, + 166, + 292, + 333, + 167, + 167, + 875, + 166, + 125, + 167, + 208, + 167, + 167, + 208, + 292, + 708, + 458, + 250, + 125, + 750, + 750, + 417, + 500, + 167, + 291, + 209, + 166, + 292, + 833, + 292, + 208, + 167, + 500, + 167, + 208, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 208, + 167, + 292, + 208, + 292, + 166, + 125, + 209, + 166, + 167, + 125, + 208, + 42, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 208, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 166, + 250, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 250, + 83, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 459, + 166, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 167, + 2625, + 47750, + 1333, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 208, + 167, + 333, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 333, + 167, + 83, + 1584, + 208, + 125, + 125, + 125, + 208, + 125, + 167, + 167, + 125, + 916, + 125, + 167, + 417, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 542, + 166, + 6375, + 375, + 3250, + 3125, + 667, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 208, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 209, + 166, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 167, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 167, + 292, + 291, + 167, + 208, + 334, + 291, + 167, + 375, + 167, + 83, + 250, + 167, + 291, + 375, + 125, + 167, + 125, + 125, + 292, + 166, + 209, + 333, + 167, + 166, + 209, + 166, + 209, + 291, + 167, + 125, + 167, + 166, + 292, + 250, + 208, + 167, + 125, + 125, + 167, + 208, + 125, + 125, + 292, + 791, + 334, + 208, + 167, + 208, + 542, + 166, + 209, + 250, + 125, + 125, + 291, + 167, + 167, + 125, + 208, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 208, + 167, + 125, + 167, + 166, + 167, + 125, + 125, + 208, + 167, + 83, + 250, + 292, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 167, + 167, + 208, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 209, + 125, + 208, + 167, + 125, + 125, + 250, + 125, + 208, + 125, + 208, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 333, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 167, + 166, + 125, + 167, + 208, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 83, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 84, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 125, + 125, + 125, + 167, + 208, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 209, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 208, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 209, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 250, + 0, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 83, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 83, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 42, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 250, + 208, + 292, + 166, + 125, + 167, + 250, + 167, + 250, + 208, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 167, + 125, + 125, + 208, + 167, + 125, + 167, + 291, + 84, + 125, + 125, + 166, + 167, + 83, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 166, + 375, + 0, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 583, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 209, + 125, + 291, + 292, + 375, + 792, + 166, + 209, + 208, + 167, + 208, + 167, + 250, + 333, + 208, + 417, + 333, + 334, + 791, + 209, + 208, + 250, + 167, + 375, + 500, + 166, + 1334, + 250, + 375, + 500, + 916, + 125, + 417, + 625, + 417, + 791, + 250, + 167, + 125, + 167, + 250, + 166, + 125, + 167, + 167, + 166, + 84, + 166, + 209, + 125, + 250, + 208, + 333, + 125, + 167, + 167, + 166, + 250, + 334, + 166, + 167, + 208, + 167, + 167, + 166, + 125, + 292, + 167, + 208, + 167, + 250, + 250, + 250, + 166, + 209, + 333, + 292, + 291, + 292, + 458, + 167, + 167, + 166, + 167, + 292, + 208, + 167, + 208, + 208, + 250, + 125, + 209, + 125, + 125, + 125, + 166, + 250, + 292, + 208, + 209, + 208, + 250, + 125, + 167, + 666, + 334, + 208, + 208, + 167, + 167, + 291, + 209, + 166, + 334, + 375, + 166, + 209, + 125, + 166, + 167, + 292, + 166, + 167, + 208, + 167, + 167, + 166, + 209, + 166, + 167, + 167, + 250, + 250, + 208, + 125, + 208, + 459, + 291, + 167, + 208, + 292, + 750, + 125, + 167, + 750, + 375, + 500, + 416, + 167, + 333, + 334, + 166, + 250, + 167, + 208, + 250, + 292, + 417, + 166, + 459, + 208, + 292, + 250, + 333, + 125, + 167, + 208, + 375, + 375, + 167, + 250, + 208, + 417, + 166, + 167, + 167, + 125, + 750, + 166, + 167, + 125, + 167, + 250, + 375, + 166, + 167, + 458, + 125, + 209, + 166, + 292, + 208, + 292, + 167, + 333, + 167, + 166, + 167, + 1000, + 583, + 500, + 209, + 166, + 917, + 542, + 375, + 250, + 166, + 417, + 500, + 167, + 166, + 250, + 167, + 208, + 500, + 375, + 250, + 459, + 583, + 250, + 292, + 416, + 125, + 167, + 167, + 166, + 459, + 250, + 291, + 167, + 167, + 500, + 291, + 292, + 208, + 209, + 208, + 125, + 500, + 125, + 167, + 1166, + 459, + 500, + 208, + 292, + 1041, + 1167, + 792, + 250, + 333, + 167, + 208, + 167, + 291, + 167, + 208, + 167, + 208, + 209, + 125, + 125, + 166, + 125, + 209, + 166, + 125, + 167, + 167, + 166, + 167, + 125, + 125, + 167, + 208, + 167, + 125, + 166, + 250, + 125, + 209, + 208, + 167, + 333, + 167, + 208, + 167, + 416, + 250, + 125, + 167, + 167, + 166, + 250, + 167, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 166, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 208, + 167, + 125, + 166, + 125, + 209, + 166, + 125, + 167, + 208, + 84, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 166, + 209, + 166, + 125, + 125, + 250, + 209, + 125, + 125, + 125, + 125, + 291, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 209, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 208, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 208, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 125, + 125, + 125, + 84, + 125, + 125, + 125, + 125, + 125, + 250, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 208, + 167, + 125, + 125, + 9208, + 6459, + 958, + 1125, + 125, + 583, + 167, + 125, + 125, + 5833, + 1209, + 5250, + 1791, + 7209, + 15708, + 125, + 167, + 166, + 209, + 166, + 167, + 250, + 167, + 125, + 166, + 167, + 167, + 41, + 167, + 167, + 208, + 167, + 166, + 167, + 167, + 125, + 125, + 125, + 83, + 167, + 166, + 125, + 750, + 167, + 167, + 166, + 125, + 125, + 167, + 167, + 333, + 167, + 208, + 125, + 167, + 166, + 125, + 167, + 167, + 125, + 5666, + 167, + 125, + 2292, + 458, + 625, + 167, + 125, + 500, + 166, + 667, + 1000, + 125, + 167, + 166, + 167, + 250, + 208, + 167, + 167, + 208, + 167, + 125, + 166, + 167, + 167, + 166, + 1792, + 208, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 83, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 208, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 208, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 84, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 209, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 250, + 0, + 167, + 167, + 166, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 41, + 84, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 84, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 208, + 83, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 250, + 166, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 250, + 42, + 166, + 125, + 167, + 42, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 41, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 333, + 84, + 83, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 208, + 292, + 167, + 291, + 167, + 167, + 208, + 167, + 500, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 208, + 125, + 209, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 83, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 209, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 209, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 209, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 250, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 208, + 167, + 125, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 84, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 83, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 167, + 166, + 167, + 167, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 41, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 83, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 208, + 167, + 125, + 208, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 84, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 167, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 41, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 209, + 166, + 167, + 83, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 83, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 42, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 125, + 84, + 166, + 84, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 166, + 167, + 125, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 42, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 83, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 166, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 208, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 167, + 167, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 209, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 166, + 167, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 42, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 167, + 166, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 84, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 209, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 250, + 125, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 167, + 167, + 125, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 83, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 209, + 166, + 125, + 125, + 125, + 167, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 167, + 83, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 166, + 125, + 125, + 125, + 125, + 125, + 167, + 42, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 125, + 167, + 167, + 125, + 166, + 125, + 167, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 84, + 166, + 125, + 125, + 167, + 125, + 250, + 125, + 167, + 208, + 167, + 166, + 167, + 125, + 167, + 125, + 208, + 83, + 209, + 125, + 125, + 125, + 125, + 166, + 125, + 125, + 167, + 167, + 166, + 125, + 125, + 167, + 125, + 125, + 125, + 125, + 167, + 125, + 125, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 166, + 125, + 167, + 125, + 167, + 125, + 125, + 166, + 125, + 167, + 167, + 208, + 125, + 250, + 167 + ] +} \ No newline at end of file diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index f4e85b29..e7965409 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -22,7 +22,7 @@ pub mod validation; use crate::bind::command::{Command, regularize_commands}; use crate::bind::prefix::{Prefix, PrefixInput}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{ErrorContext, Result, ResultVec, err, wrn}; +use crate::error::{ErrorContext, ParseError, Result, ResultVec, err, wrn}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; @@ -176,7 +176,7 @@ pub struct BindingInput { doc: Option, #[serde(flatten)] - other_fields: HashMap>, + other_fields: HashMap, } /// @forBindingField bind @@ -423,7 +423,7 @@ pub struct BindingDocInput { pub kind: Option>>, #[serde(flatten)] - other_fields: HashMap>, + other_fields: HashMap, } #[allow(non_snake_case)] @@ -437,7 +437,7 @@ pub struct CombinedBindingDocInput { pub description: Option>>, #[serde(flatten)] - other_fields: HashMap>, + other_fields: HashMap, } impl Merging for BindingDocInput { @@ -559,28 +559,6 @@ impl Expanding for CombinedBindingDocInput { } } -impl Resolving for Option { - fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { - match self { - Some(doc) => Ok(BindingDoc::new(doc, scope)?), - Option::None => Ok(BindingDoc::default()), - } - } -} - -impl Resolving> for Option { - fn resolve( - self, - _name: &'static str, - scope: &mut Scope, - ) -> ResultVec> { - return match self { - Some(doc) => Ok(Some(CombinedBindingDoc::new(doc, scope)?)), - Option::None => Ok(None), - }; - } -} - // // ================ Legacy `[[bind]]` warnings ================ // @@ -641,8 +619,8 @@ impl LegacyBindingInput { if modes.len() == 0 { let err: Result<()> = Err(wrn!( - "2.0 no longer supports expressions; all modes using an empty array\ - use the expression `{}` instead", + "2.0 does not use an empty array to indicate all modes are valid for \ + a keybinding; use the expression `{}` instead", "{{all_modes()}}" )) .with_range(&span); @@ -802,7 +780,11 @@ impl Binding { return Ok(commands); } - pub(crate) fn new(input: BindingInput, scope: &mut Scope) -> ResultVec { + pub(crate) fn new( + input: BindingInput, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { let commands = regularize_commands(&input, scope)?; // id validation @@ -866,6 +848,15 @@ impl Binding { ) }; + // warning about unknown fields + for (key, _) in input.other_fields { + let err: Result<()> = Err(wrn!( + "The field `{}` is unrecognized and will be ignored", + key, + )); + warnings.push(err.unwrap_err()); + } + // resolve all keys to appropriate types let result = Binding { commands: commands, @@ -877,7 +868,10 @@ impl Binding { finalKey, repeat: resolve!(input, repeat, scope)?, tags: resolve!(input, tags, scope)?, - doc: resolve!(input, doc, scope)?, + doc: match input.doc { + Some(x) => BindingDoc::new(x, scope, warnings)?, + Option::None => BindingDoc::default(), + }, }; return Ok(result); @@ -979,7 +973,11 @@ pub struct CombinedBindingDoc { #[wasm_bindgen] impl BindingDoc { - pub(crate) fn new(input: BindingDocInput, scope: &mut Scope) -> ResultVec { + pub(crate) fn new( + input: BindingDocInput, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { // kind validation let kind_span = input.kind.as_ref().map(|x| x.span()); let kind: Option = resolve!(input, kind, scope)?; @@ -989,12 +987,25 @@ impl BindingDoc { } }; + // warning about unknown fields + for (key, _) in input.other_fields { + let err: Result<()> = Err(wrn!( + "The field `{}` is unrecognized and will be ignored", + key, + )); + warnings.push(err.unwrap_err()); + } + return Ok(BindingDoc { name: resolve!(input, name, scope)?, description: resolve!(input, description, scope)?, hideInPalette: resolve!(input, hideInPalette, scope)?, hideInDocs: resolve!(input, hideInDocs, scope)?, - combined: resolve!(input, combined, scope)?, + combined: match input.combined { + Some(x) => Some(CombinedBindingDoc::new(x, scope, warnings)?), + Option::None => None, + }, + kind, }); } @@ -1002,7 +1013,20 @@ impl BindingDoc { #[wasm_bindgen] impl CombinedBindingDoc { - pub(crate) fn new(input: CombinedBindingDocInput, scope: &mut Scope) -> ResultVec { + pub(crate) fn new( + input: CombinedBindingDocInput, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { + // warning about unknown fields + for (key, _) in input.other_fields { + let err: Result<()> = Err(wrn!( + "The field `{}` is unrecognized and will be ignored", + key, + )); + warnings.push(err.unwrap_err()); + } + return Ok(CombinedBindingDoc { name: resolve!(input, name, scope)?, key: resolve!(input, key, scope)?, @@ -1501,7 +1525,9 @@ mod tests { let hideInPalette: bool = resolve!(doc, hideInPalette, &mut scope).unwrap(); assert_eq!(hideInPalette, false); - let combined: CombinedBindingDoc = resolve!(doc, combined, &mut scope).unwrap().unwrap(); + let mut _warnings = Vec::new(); + let combined: CombinedBindingDoc = + CombinedBindingDoc::new(doc.combined.unwrap(), &mut scope, &mut _warnings).unwrap(); assert_eq!(combined.name, "Up/down"); assert_eq!(combined.key, "A/B"); assert_eq!(combined.description, "bla bla bla"); @@ -1578,8 +1604,7 @@ mod tests { assert_eq!(prefix_strs, ["b".to_string(), "c".to_string()]); let doc = left.doc.unwrap(); - let combined: Option = resolve!(doc, combined, &mut scope).unwrap(); - assert!(combined.is_none()); + assert!(doc.combined.is_none()); } #[test] @@ -1607,7 +1632,10 @@ mod tests { let expected = result.get("bind").unwrap()[2].clone(); let left = default.merge(left); - assert_eq!(left.args, expected.args); + assert_eq!( + left.args.unwrap().into_inner(), + expected.args.unwrap().into_inner() + ); } #[test] @@ -1742,7 +1770,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); scope.parse_asts(&input).unwrap(); - let result = Binding::new(input, &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = Binding::new(input, &mut scope, &mut warnings).unwrap(); scope.state.set_or_push("joe", Dynamic::from("fiz")); let flat_args: toml::Value = result.commands(&mut scope).unwrap()[0].clone().args.into(); @@ -1766,7 +1795,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - let err = Binding::new(input, &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = Binding::new(input, &mut scope, &mut warnings).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("Undefined mode")); assert_eq!(report[0].range.start.line, 3); @@ -1783,7 +1813,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - let err = Binding::new(input, &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = Binding::new(input, &mut scope, &mut warnings).unwrap_err(); let report = format!("{err}"); assert!(report.contains("`finalKey`")); } @@ -1797,7 +1828,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - let result = Binding::new(input, &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = Binding::new(input, &mut scope, &mut warnings).unwrap(); assert!(result.when.unwrap().contains("editorTextFocus")) } @@ -1811,7 +1843,8 @@ mod tests { let input = toml::from_str::(data).unwrap(); let mut scope = Scope::new(); - let result = Binding::new(input, &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = Binding::new(input, &mut scope, &mut warnings).unwrap(); assert!(result.when.unwrap().contains("keybindingPaletteOpen")); } diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 471d75ab..747f5a12 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -36,7 +36,6 @@ use crate::bind::BindingInput; use indexmap::IndexMap; -use lazy_static::lazy_static; #[allow(unused_imports)] use log::info; use regex::Regex; @@ -242,11 +241,6 @@ const ALL_KEYS: [&'static str; 192] = [ "[NumpadDivide]", ]; -lazy_static! { - static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); - // static ref KEY_PATTERN_REGEX: Regex = Regex::new(r"^\s*keys\(\s*`(.*)`\s*\)\s*$").unwrap(); -} - #[allow(non_snake_case)] pub fn expression_fn__keys( val: ImmutableString, diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index 920f5b0e..ff0069d8 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -12,11 +12,11 @@ use toml::Spanned; use crate::bind::BindingInput; use crate::bind::command::CommandInput; use crate::bind::validation::BindingReference; -use crate::err; -use crate::error::{ErrorContext, ParseError, ResultVec, err}; +use crate::error::{ErrorContext, ParseError, Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, Value}; use crate::util::{Merging, Resolving}; +use crate::{err, wrn}; /// @bindingField define /// @description object of arbitrary fields which can be used in @@ -168,6 +168,9 @@ pub struct DefineInput { /// defaults, allowing for a hierarchy of defaults if so desired. /// pub bind: Option>>, + + #[serde(flatten)] + other_fields: HashMap, } #[derive(Clone, Debug, Default, Serialize)] @@ -185,7 +188,11 @@ lazy_static! { } impl Define { - pub fn new(input: DefineInput, scope: &mut Scope) -> ResultVec { + pub fn new( + input: DefineInput, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { let mut resolved_bind = HashMap::::new(); let mut resolved_command = HashMap::::new(); let mut resolved_var = HashMap::::new(); @@ -240,6 +247,20 @@ impl Define { } } + // warning about unknown fields + for (key, _) in &input.other_fields { + // XXX:: we have no good way of detecting the byte range of these items using + // TOML without radically change the `DefineInput` data structure. We fallback + // to showing an error at the top of the file (UNKNOWN_RANGE values are expected + // to be resolved by the time we print out an error, so we can't use that) + let err: Result<()> = Err(wrn!( + "The `define.{}` section in this file is unrecognized and will be ignored", + key, + )) + .with_range(&(0..1)); + warnings.push(err.unwrap_err()); + } + if errors.len() > 0 { return Err(errors.into()); } else { @@ -348,7 +369,13 @@ mod tests { "#; let mut scope = Scope::new(); - let result = Define::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = Define::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.val.get("y").unwrap(), &Value::String("bill".into())); assert_eq!(result.val.get("joe").unwrap(), &Value::String("bob".into())); diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 1e324b09..6d0387b1 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -398,7 +398,11 @@ impl ParseError { let msg = LINE_MESSAGE.replace_all(&raw_msg, ""); message_buf.push_str(&msg); } - _ => message_buf.push_str(&self.error.to_string()), + _ => { + let raw_msg = &self.error.to_string(); + let msg = LINE_MESSAGE.replace_all(&raw_msg, ""); + message_buf.push_str(&msg); + } }; for context in &self.contexts { match context { diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 487d9af9..38f3a84b 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -150,11 +150,12 @@ impl Scope { let dynamic: Dynamic = self .engine .eval_ast_with_scope(&mut self.state, ast) + .with_message(format!(" while evaluating {expr}")) .with_exp_range(&expr.span)?; self.state.rewind(rewind_to); let result_value: std::result::Result = dynamic.clone().try_into(); let value = result_value - .with_message(format!(" while evaluating:\n{expr}")) + .with_message(format!(" while evaluating {expr}")) .with_exp_range(&expr.span)?; return Ok(value); })?); @@ -365,7 +366,6 @@ mod tests { let message = report.first().unwrap().message.clone(); let range = report.first().unwrap().range.clone(); let val: String = data[(range.start.col)..=(range.end.col)].to_string(); - info!("report: {report:#?}"); assert!(message.contains("unexpected `{{`")); } @@ -382,7 +382,6 @@ mod tests { let message = report.first().unwrap().message.clone(); let range = report.first().unwrap().range.clone(); let val: String = data[(range.start.col)..=(range.end.col)].to_string(); - info!("report: {report:#?}"); assert!(message.contains("unexpected `{{`")); } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index 2a0d3a1d..f43b894f 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -29,7 +29,7 @@ use crate::util::{LeafValue, Merging, Plural, Required, Resolving}; /// to represent parsed TOML data, expand the expressions in them, and translate /// those values to JSON and/or Rhai `Dynaamic` objects. -#[derive(Serialize, Debug, Clone, PartialEq)] +#[derive(Serialize, Debug, Clone)] pub enum Value { Integer(i32), Float(f64), @@ -44,6 +44,22 @@ pub enum Value { Exp(Expression), } +impl PartialEq for Value { + fn eq(&self, other: &Self) -> bool { + return match (self, other) { + (Value::Integer(x), Value::Integer(y)) => x == y, + (Value::Float(x), Value::Float(y)) => x == y, + (Value::String(x), Value::String(y)) => x == y, + (Value::Boolean(x), Value::Boolean(y)) => x == y, + (Value::Array(x), Value::Array(y)) => x == y, + (Value::Table(x, _), Value::Table(y, _)) => x == y, + (Value::Interp(x), Value::Interp(y)) => x == y, + (Value::Exp(x), Value::Exp(y)) => x == y, + _ => false, + }; + } +} + // // ---------------- Value: Expressions ---------------- // diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index d4e9b6c1..ce4b918f 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -124,7 +124,9 @@ use crate::bind::{ Binding, BindingCodes, BindingInput, BindingOutput, KeyId, LegacyBindingInput, UNKNOWN_RANGE, }; use crate::define::{Define, DefineInput}; -use crate::error::{ErrorContext, ErrorReport, ErrorSet, Result, ResultVec, flatten_errors}; +use crate::error::{ + Context, ErrorContext, ErrorReport, ErrorSet, ParseError, Result, ResultVec, flatten_errors, +}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, Value}; use crate::kind::Kind; @@ -161,13 +163,18 @@ pub struct KeyFile { mode: Modes, bind: Vec, kind: HashMap, + // TODO: avoid storing `key_bind` to make serialization smaller key_bind: Vec, } impl KeyFile { // TODO: refactor to have each section's processing in corresponding module // for that section - fn new(input: KeyFileInput, mut scope: &mut Scope) -> ResultVec { + fn new( + input: KeyFileInput, + mut scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { let mut errors = Vec::new(); // [header] @@ -182,7 +189,7 @@ impl KeyFile { // [[define]] let define_input = input.define.unwrap_or_default(); - let mut define = match Define::new(define_input, &mut scope) { + let mut define = match Define::new(define_input, &mut scope, warnings) { Err(mut es) => { errors.append(&mut es.errors); Define::default() @@ -194,7 +201,7 @@ impl KeyFile { let mode_input = input .mode .unwrap_or_else(|| vec![Spanned::new(UNKNOWN_RANGE, ModeInput::default())]); - let modes = match Modes::new(mode_input, &mut scope) { + let modes = match Modes::new(mode_input, &mut scope, warnings) { Err(mut es) => { errors.append(&mut es.errors); Modes::default() @@ -203,7 +210,7 @@ impl KeyFile { }; // [[kind]] - let kind = Kind::process(&input.kind, &mut scope)?; + let kind = Kind::process(&input.kind, &mut scope, warnings)?; // [[bind]] let input_iter = input @@ -241,7 +248,15 @@ impl KeyFile { let items = replicates .into_iter() - .map(|x| Ok((Binding::new(x, &mut scope)?, span.clone()))) + .map(|x| { + let mut bind_warnings = Vec::new(); + let bind = Binding::new(x, &mut scope, &mut bind_warnings)?; + bind_warnings + .iter_mut() + .for_each(|w| w.contexts.push(Context::Range(span.clone()))); + warnings.append(&mut bind_warnings); + Ok((bind, span.clone())) + }) .collect::>>() .with_range(&span); match items { @@ -259,6 +274,7 @@ impl KeyFile { } }) .unzip(); + bind = Binding::resolve_prefixes(bind, &bind_span)?; // TODO: store spans so we can do avoid serializing this data?? @@ -305,26 +321,28 @@ pub struct KeyFileResult { // These lines are tested during integration tests with the typescript code #[wasm_bindgen] pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { - return match parse_bytes_helper(&file_content) { - Ok((result, warnings)) => KeyFileResult { + let mut warnings = Vec::new(); + let result = parse_bytes_helper(&file_content, &mut warnings); + return match result { + Ok(result) => KeyFileResult { file: Some(result), + errors: Some(warnings.iter().map(|e| e.report(&file_content)).collect()), + }, + Err(err) => KeyFileResult { + file: None, errors: Some( - warnings - .errors + err.errors .iter() + .chain(warnings.iter()) .map(|e| e.report(&file_content)) .collect(), ), }, - Err(err) => KeyFileResult { - file: None, - errors: Some(err.errors.iter().map(|e| e.report(&file_content)).collect()), - }, }; } // LCOV_EXCL_STOP -fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { +fn parse_bytes_helper(file_content: &[u8], warnings: &mut Vec) -> ResultVec { // ensure there's a directive // we know that the content was converted from a string on the typescript side // so we're cool with an unchecked conversion @@ -360,7 +378,7 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { let mut scope = Scope::new(); // TODO: do something with this scope?? let bind = parsed.bind.clone(); - let result = KeyFile::new(parsed, &mut scope); + let result = KeyFile::new(parsed, &mut scope, warnings); let legacy_check = bind.map_expressions(&mut |ex @ Expression { .. }| { if OLD_EXPRESSION.is_match(&ex.content) { @@ -372,17 +390,11 @@ fn parse_bytes_helper(file_content: &[u8]) -> ResultVec<(KeyFile, ErrorSet)> { } return Ok(Value::Exp(ex)); }); - let mut warnings = match legacy_check { - Err(e) => e, - Ok(_) => vec![].into(), + match legacy_check { + Err(mut e) => warnings.append(&mut e.errors), + Ok(_) => (), }; - match result { - Ok(key_file) => Ok((key_file, warnings)), - Err(mut e) => Err({ - e.errors.append(&mut warnings.errors); - e - }), - } + return result; } // @@ -486,7 +498,8 @@ pub(crate) mod tests { command = "cursorLeft" "#; - let (result, _) = parse_bytes_helper(data.as_bytes()).unwrap(); + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap(); assert_eq!(result.bind[0].key[0], "l"); assert_eq!(result.bind[0].commands[0].command, "cursorRight"); @@ -506,8 +519,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("version")); assert_eq!(report[0].range.start.line, 2); @@ -524,7 +542,8 @@ pub(crate) mod tests { command = "b" "#; - let err = parse_bytes_helper(data.as_bytes()).unwrap_err(); + let mut warnings = Vec::new(); + let err = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("directive")); assert_eq!(report[0].range.start.line, 0); @@ -558,8 +577,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key[0], "a"); @@ -612,8 +636,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.bind[0].doc.name, "the whole shebang"); assert_eq!(result.bind[0].key[0], "a"); @@ -651,8 +680,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); let expected_name: Vec = (0..9).into_iter().map(|n| format!("update {n}")).collect(); @@ -694,13 +728,48 @@ pub(crate) mod tests { // TODO: ensure that a proper span is shown here let mut scope = Scope::new(); - let result = KeyFile::new(toml::from_str::(data).unwrap(), &mut scope); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ); let report = result.unwrap_err().report(data.as_bytes()); assert_eq!(report[0].message, "`key` field is required".to_string()); assert_eq!(report[0].range.start.line, 4); assert_eq!(report[0].range.end.line, 4); } + #[test] + fn foreach_regex_error() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + foreach.key = ["{{keys(`[0-9`)}}"] + key = "c {{key}}" + doc.name = "update {{key}}" + command = "foo" + args.value = "{{key}}" + "#; + + // TODO: ensure that a proper span is shown here + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ); + let report = result.unwrap_err().report(data.as_bytes()); + info!("reprot: {report:#?}"); + assert!(report[0].message.contains("regex parse error")); + assert!(!report[0].message.contains("(line")); + assert_eq!(report[0].range.start.line, 5); + assert_eq!(report[0].range.end.line, 5); + } + #[test] fn define_val_at_read() { let data = r#" @@ -717,8 +786,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.bind[0].commands[0].command, "bar"); } @@ -738,8 +812,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("default mode already set")); assert_eq!(report[0].range.start.line, 8) @@ -759,8 +838,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!( report[0] @@ -785,8 +869,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode name is not unique")); assert_eq!(report[0].range.start.line, 8) @@ -808,8 +897,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!( result.mode.get("b").unwrap().whenNoBinding, crate::mode::WhenNoBinding::UseMode("a".to_string()) @@ -832,8 +926,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `c` is not defined")); assert_eq!(report[0].range.start.line, 10) @@ -867,8 +966,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert!(result.bind[0].mode.iter().any(|x| x == "a")); assert!(result.bind[0].mode.iter().any(|x| x == "b")); assert!(result.bind[0].mode.iter().any(|x| x == "c")); @@ -900,8 +1004,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `d`")); assert_eq!(report[0].range.start.line, 17) @@ -945,8 +1054,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert!( unwrap_prefixes(&result.bind[2].prefixes) .iter() @@ -1017,8 +1131,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("undefined: `d k`")); @@ -1059,8 +1178,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); let commands = result.bind[0].commands(&mut scope).unwrap(); assert_eq!(commands[0].command, "x"); assert_eq!(commands[1].command, "j"); @@ -1106,8 +1230,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("`finalKey`")); assert_eq!(report[0].range.start.line, 13); @@ -1147,8 +1276,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); let err = result.bind[0].commands(&mut scope).unwrap_err(); assert!(format!("{err}").contains("`finalKey`")) } @@ -1172,8 +1306,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.key_bind.len(), 2); if let BindingOutput::Do { key, @@ -1224,8 +1363,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("Duplicate key")); @@ -1246,11 +1390,62 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let result = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap(); assert_eq!(result.key_bind.len(), 8) } + #[test] + fn raises_unknown_key_warning() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "foo" + comand = "bar" + doc.blat = 1 + doc.combined.bar = 2 + + [[kind]] + name = "biz" + description = "buzz" + descriptn = "baz" + + [[mode]] + name = "normal" + default = true + nme = "beep" + + [[define.google]] + bob = "x" + "#; + + let mut warnings = Vec::new(); + let _result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let warnings: ErrorSet = warnings.into(); + let report = warnings.report(data.as_bytes()); + let unrecognized: Vec<_> = report + .iter() + .filter(|x| x.message.contains("is unrecognized")) + .collect(); + assert_eq!(unrecognized[0].range.start.line, 0); + assert_eq!(unrecognized[1].range.start.line, 18); + assert_eq!(unrecognized[2].range.start.line, 13); + assert_eq!(unrecognized[3].range.start.line, 6); + assert_eq!(unrecognized[4].range.start.line, 6); + assert_eq!(unrecognized[5].range.start.line, 6); + assert_eq!(unrecognized.len(), 6); + } + #[test] fn raises_legacy_warnings() { let data = r#" @@ -1286,7 +1481,15 @@ pub(crate) mod tests { "#; let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); - assert_eq!(warnings.errors.len(), 14); + assert_eq!( + warnings + .errors + .iter() + .filter(|x| x.error.to_string().contains("2.0")) + .collect::>() + .len(), + 14 + ); } #[test] @@ -1311,8 +1514,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("`bleep`")); @@ -1332,8 +1540,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("Expecting ')'")); assert_eq!(report[0].range.start.line, 7); @@ -1355,8 +1568,13 @@ pub(crate) mod tests { "#; let mut scope = Scope::new(); - let err = - KeyFile::new(toml::from_str::(data).unwrap(), &mut scope).unwrap_err(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("unexpected `{{`")); assert_eq!(report[0].range.start.line, 7); diff --git a/src/rust/parsing/src/kind.rs b/src/rust/parsing/src/kind.rs index ecce92b5..7fa76f54 100644 --- a/src/rust/parsing/src/kind.rs +++ b/src/rust/parsing/src/kind.rs @@ -5,9 +5,9 @@ use serde::Deserialize; use std::collections::HashMap; use toml::Spanned; -use crate::err; -use crate::error::{ErrorContext, ResultVec}; +use crate::error::{ErrorContext, ParseError, Result, ResultVec}; use crate::expression::Scope; +use crate::{err, wrn}; /// @forBindingField kind /// @@ -41,12 +41,15 @@ use crate::expression::Scope; pub struct Kind { name: String, description: String, + #[serde(flatten)] + other_fields: HashMap, } impl Kind { pub(crate) fn process( input: &Option>>, scope: &mut Scope, + warnings: &mut Vec, ) -> ResultVec> { let mut kinds = HashMap::new(); if let Some(input) = input { @@ -57,6 +60,16 @@ impl Kind { return Err(err!("Kind `name` must be unique.")).with_range(&span)?; } + // warning about unknown fields + for (key, _) in &kind_input.other_fields { + let err: Result<()> = Err(wrn!( + "The field `{}` is unrecognized and will be ignored", + key, + )) + .with_range(&span); + warnings.push(err.unwrap_err()); + } + kinds.insert(kind_input.name.clone(), kind_input.description.clone()); } scope.kinds = kinds.keys().map(|x| x.clone()).collect(); diff --git a/src/rust/parsing/src/mode.rs b/src/rust/parsing/src/mode.rs index e50c5520..b58c2ae1 100644 --- a/src/rust/parsing/src/mode.rs +++ b/src/rust/parsing/src/mode.rs @@ -9,11 +9,11 @@ use wasm_bindgen::prelude::*; use crate::bind::UNKNOWN_RANGE; use crate::bind::command::{Command, CommandInput}; -use crate::err; -use crate::error::{ErrorContext, ResultVec, err}; +use crate::error::{Context, ErrorContext, ParseError, Result, ResultVec, err}; use crate::expression::Scope; use crate::resolve; use crate::util::{LeafValue, Plural, Resolving}; +use crate::{err, wrn}; /// @bindingField mode /// @description array describing behavior of keybinding modes @@ -99,6 +99,9 @@ pub struct ModeInput { /// when [running multiple commands](#running-multiple-commands) in `[[bind]]`. #[serde(default)] whenNoBinding: Option>, + + #[serde(flatten)] + other_fields: HashMap, } impl Default for ModeInput { @@ -109,6 +112,7 @@ impl Default for ModeInput { highlight: None, cursorShape: None, whenNoBinding: Some(Spanned::new(UNKNOWN_RANGE, WhenNoBindingInput::Insert)), + other_fields: HashMap::new(), }; } } @@ -181,7 +185,11 @@ impl Resolving for WhenNoBindingInput { #[wasm_bindgen] impl Mode { - pub(crate) fn new(input: ModeInput, scope: &mut Scope) -> ResultVec { + pub(crate) fn new( + input: ModeInput, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { if let Some(ref x) = input.whenNoBinding { let span = x.span().clone(); if let WhenNoBindingInput::UseMode(mode) = x.as_ref() { @@ -190,6 +198,16 @@ impl Mode { } } } + + // warning about unknown fields + for (key, _) in &input.other_fields { + let err: Result<()> = Err(wrn!( + "The field `{}` is unrecognized and will be ignored", + key, + )); + warnings.push(err.unwrap_err()); + } + return Ok(Mode { name: resolve!(input, name, scope)?, default: resolve!(input, default, scope)?, @@ -208,7 +226,11 @@ pub struct Modes { } impl Modes { - pub(crate) fn new(input: Vec>, scope: &mut Scope) -> ResultVec { + pub(crate) fn new( + input: Vec>, + scope: &mut Scope, + warnings: &mut Vec, + ) -> ResultVec { // define the set of available modes let mut all_mode_names = HashSet::new(); let mut default_mode = None; @@ -279,10 +301,15 @@ impl Modes { let mut modes = HashMap::new(); for mode in input { let span = mode.span().clone(); + let mut mode_warnings = Vec::new(); modes.insert( mode.as_ref().name.clone(), - Mode::new(mode.into_inner(), scope).with_range(&span)?, + Mode::new(mode.into_inner(), scope, &mut mode_warnings).with_range(&span)?, ); + mode_warnings + .iter_mut() + .for_each(|w| w.contexts.push(Context::Range(span.clone()))); + warnings.append(&mut mode_warnings) } return Ok(Modes { @@ -304,9 +331,3 @@ impl Default for Modes { }; } } - -impl Resolving for ModeInput { - fn resolve(self, _name: &'static str, scope: &mut Scope) -> ResultVec { - return Ok(Mode::new(self, scope)?); - } -} From ce8fd3e440261b7b25c12c2a5a4ff51c899995c6 Mon Sep 17 00:00:00 2001 From: David Little Date: Wed, 15 Oct 2025 18:07:52 -0400 Subject: [PATCH 75/79] key binding validation tested Created using spr 1.3.6-beta.1 --- .vscode/settings.json | 2 +- notes.md | 6 +- src/rust/parsing/src/bind/validation.rs | 20 ++++-- src/rust/parsing/src/file.rs | 91 +++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 9 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 39d2d447..158dcc9f 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -15,7 +15,7 @@ "rust-analyzer.cargo.sysrootSrc": "${userHome}/.rustup/toolchains/1.90.0-aarch64-apple-darwin/lib/rustlib/src/rust", "rust-analyzer.checkOnSave": true, "rust-analyzer.cargo.allTargets": false, - "rust-analyzer.cargo.buildScripts.rebuildOnSave": false, + "rust-analyzer.cargo.buildScripts.rebuildOnSave": true, "workbench.colorCustomizations": { "iLoveWorkSpaceColors": false, "iLoveWorkSpaceRandom": false, diff --git a/notes.md b/notes.md index 51fa831a..2d93e960 100644 --- a/notes.md +++ b/notes.md @@ -279,9 +279,9 @@ Integration test debugging: or maybe we should create an object that contains scope and pass that to resolve because the name is starting to be misleading - [X] invalid regex for `keys` function - - [ ] invalid keybinding strings (modifier and key) - - [ ] layout invariant binding works - - [ ] expression evaluating to non-string value for `key` field + - [X] invalid keybinding strings (modifier and key) + - [X] layout invariant binding works + - [X] expression evaluating to non-string value for `key` field - [ ] unresolved expressions when converting from Value -> toml::Value - [ ] errors in an expression of a `[[bind]]` field point to the field - [ ] for top-level diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 8fb0e1c9..8185ee73 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -5,6 +5,7 @@ use lazy_static::lazy_static; use regex::Regex; use serde::{Deserialize, Serialize}; +use crate::err; use crate::error::{ErrorSet, Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{EXPRESSION, Expanding, Expression, TypedValue, Value}; @@ -99,18 +100,27 @@ lazy_static! { ]; } +fn is_exact_match(x: &Regex, val: &str) -> bool { + if let Some(m) = x.find(val) { + return m.range().len() == val.len(); + } else { + return false; + } +} + fn valid_key_binding_str(str: &str) -> Result<()> { for press in Regex::new(r"\s+").unwrap().split(str) { let mut first = true; for part in press.split('+').rev() { if first { first = false; - if !KEY_REGEXS.iter().any(|r| r.is_match(part)) { - return Err(err("`{part}` is an invalid key"))?; + // TODO: don't use is_match (use something to check that the full string matches) + if !KEY_REGEXS.iter().any(|r| is_exact_match(&r, part)) { + return Err(err!("`{part}` is an invalid key"))?; } } else { - if !MODIFIER_REGEX.is_match(part) { - return Err(err("`{part}` is an invalid modiier key"))?; + if !is_exact_match(&MODIFIER_REGEX, part) { + return Err(err!("`{part}` is an invalid modifier key"))?; } } } @@ -174,7 +184,7 @@ impl Expanding for KeyBinding { result.push_str(&format!("{toml:?}")); } }; - return Err(err("expected a string, found `{result}`"))?; + return Err(err!("expected a string, found `{result}`"))?; } }, }) diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index ce4b918f..0fe6ffe5 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -1583,6 +1583,97 @@ pub(crate) mod tests { assert_eq!(report[0].range.end.col, 41); } + #[test] + fn invalid_key_modifier_error() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + command = "bar" + key = "crd+x" + "#; + + let err = toml::from_str::(data).unwrap_err(); + let err: ParseError = err.into(); + let report = err.report(data.as_bytes()); + assert!(report.message.contains("invalid modifier")); + assert_eq!(report.range.start.line, 6); + assert_eq!(report.range.end.line, 6); + assert_eq!(report.range.start.col, 14); + assert_eq!(report.range.end.col, 21); + } + + #[test] + fn invalid_key_name_error() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + command = "foo" + key = "xyz" + "#; + + let err = toml::from_str::(data).unwrap_err(); + let err: ParseError = err.into(); + let report = err.report(data.as_bytes()); + assert!(report.message.contains("invalid key")); + assert_eq!(report.range.start.line, 6); + assert_eq!(report.range.end.line, 6); + assert_eq!(report.range.start.col, 14); + assert_eq!(report.range.end.col, 19); + } + + #[test] + fn invariant_key_name_parses() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + command = "foo" + key = "[KeyX]" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let result = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ); + assert!(result.is_ok()); + } + + #[test] + fn non_string_key_eval_errors() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + command = "foo" + key = "{{1+2}}" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); + + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("expected a string")); + assert_eq!(report[0].range.start.line, 6); + assert_eq!(report[0].range.end.line, 6); + assert_eq!(report[0].range.start.col, 14); + assert_eq!(report[0].range.end.col, 23); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) From 4e2e7093d557f3b08202a17b03618d6ac0af7a92 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 17 Oct 2025 17:23:45 -0400 Subject: [PATCH 76/79] tests for all identified error conditions Created using spr 1.3.6-beta.1 --- notes.md | 48 +-- src/rust/parsing/src/bind.rs | 32 +- src/rust/parsing/src/bind/command.rs | 28 +- src/rust/parsing/src/bind/prefix.rs | 10 +- src/rust/parsing/src/bind/validation.rs | 4 +- src/rust/parsing/src/define.rs | 23 +- src/rust/parsing/src/error.rs | 21 +- src/rust/parsing/src/expression.rs | 55 +-- src/rust/parsing/src/expression/value.rs | 94 +++-- src/rust/parsing/src/file.rs | 446 +++++++++++++++++++++-- src/rust/parsing/src/util.rs | 106 +++--- 11 files changed, 681 insertions(+), 186 deletions(-) diff --git a/notes.md b/notes.md index 2d93e960..227b14ba 100644 --- a/notes.md +++ b/notes.md @@ -282,33 +282,33 @@ Integration test debugging: - [X] invalid keybinding strings (modifier and key) - [X] layout invariant binding works - [X] expression evaluating to non-string value for `key` field - - [ ] unresolved expressions when converting from Value -> toml::Value - - [ ] errors in an expression of a `[[bind]]` field point to the field - - [ ] for top-level - - [ ] for docs - - [ ] for combined docs - - [ ] id field is reserved - - [ ] foreach with unresolved variables - - [ ] error in expression of `define.val/command/bind` - - [ ] allow expression interpolations to be keybindings - - [ ] an expression that isn't `{{bind.[id]}}` for a `default` field - - [ ] undefined `{{bind.[id]}}` reference in `default` field - - [ ] misplaced reference to `{{bind.[id]}}` - - [ ] TOML parsing errors - - [ ] error for use of legacy expression () - - [ ] unique kind names - - [ ] args set to non-table value when `command = "runCommands"` - - [ ] `args.commands` being a non-array value when `command = "runCommands"` - - [ ] non string value for `command` inside of `args.commands` - - [ ] `skipWhen` present for `command = "runCommands"` for an element + - [X] unresolved expressions when converting from Value -> toml::Value + - [X] id field is reserved + - [X] error in expression of `define.val/command/bind` + - [X] expression errors in `define.val` show up + - [X] `command` errors show up + - [X] `bind` errors show up + - [X] an expression that isn't `{{bind.[id]}}` for a `default` field + - [X] undefined `{{bind.[id]}}` reference in `default` field + - [X] errors in an expression of a `[[bind]]` field point to the field + - [X] for top-level + - [X] for docs + - [X] for combined docs + - [X] misplaced reference to `{{bind.[id]}}` + - [X] TOML parsing errors + - [X] unique kind names + - [X] args set to non-table value when `command = "runCommands"` + - [X] `args.commands` being a non-array value when `command = "runCommands"` + - [X] non string value for `command` inside of `args.commands` + - [X] `skipWhen` present for `command = "runCommands"` for an element of `args.commands`. - - [ ] args is a non array or table value for a sub command of `runCommands` - - [ ] non table or string value for an array element of `runCommands` + - [X] args is a non array or table value for a sub command of `runCommands` + - [X] non table or string value for an array element of `runCommands` - [ ] review coverage to verify there aren't additional checks we're missing - - [ ] test that all error messages show up when expected - - [ ] make sure a range is always provided + - [X] test that all error messages show up when expected + - [X] make sure a range is always provided - [ ] integration test for both warnings and errors in type script setup - - [ ] validate modes to ensure that at least one allows the user to type 😬 + - [ ] validate modes to ensure that at least one of them allows the user to type 😬 - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index e7965409..063f82da 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -794,7 +794,9 @@ impl Binding { // foreach validation if let Some(_) = input.foreach { - return Err(err("`foreach` included unresolved variables"))?; + // we do not expect this to ever happen, `expand_foreach` + // should always be executed before `new` + panic!("`foreach` included unresolved variables"); // LCOV_EXCL_LINE } // finalKey validation @@ -1563,6 +1565,22 @@ mod tests { assert_eq!(when, None); } + #[test] + fn reserved_id_field() { + let data = r#" + id = "biz" + key = "a" + command = "foo" + "#; + + let input = toml::from_str::(data).unwrap(); + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = Binding::new(input, &mut scope, &mut warnings).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("`id` field")); + } + #[test] fn simple_command_merging() { let data = r#" @@ -1848,6 +1866,18 @@ mod tests { assert!(result.when.unwrap().contains("keybindingPaletteOpen")); } + #[test] + fn default_is_wrong_type() { + let data = r#" + key = "a" + command = "foo" + default = "{{1+2}}" + "#; + + let err = toml::from_str::(data).unwrap_err(); + assert!(err.to_string().contains("default must")); + } + // TODO: are there any edge cases / failure modes I want to look at in the tests // (most of the things seem likely to be covered by serde / toml parsing, and the // stuff I would want to check should be done at a higher level when I'm working diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index bbe6109a..ea6b8d0f 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -167,6 +167,15 @@ impl CommandInputLike for Command { } } +fn maybe_span(spans: Option>>, key: &str) -> Option> { + if let Some(spans) = spans { + if let Some(span) = spans.get(key) { + return Some(span.clone()); + } + } + return None; +} + pub(crate) fn regularize_commands( input: &impl CommandInputLike, scope: &mut Scope, @@ -231,8 +240,9 @@ pub(crate) fn regularize_commands( let command_name = match result { Value::String(x) => x.to_owned(), _ => { - return Err(err("expected `command` to be a string")) - .with_range(&args_pos)?; + return Err(err("expected `command` to be a string")).with_range( + &maybe_span(spans, "command").unwrap_or(args_pos.clone()), + )?; } }; // check for recursive `runCommands` call @@ -244,7 +254,9 @@ pub(crate) fn regularize_commands( Err(err( "`skipWhen` is not supported on a `runCommands` command", )) - .with_range(&args_pos)?; + .with_range( + &maybe_span(spans, "skipWhen").unwrap_or(args_pos.clone()), + )?; } let mut commands = regularize_commands( &(CommandValue { @@ -265,8 +277,11 @@ pub(crate) fn regularize_commands( x @ Value::Table(_, _) => x, x @ Value::Array(_) => x, x @ Value::Exp(_) => x, - x => { - return Err(err("expected `args` to be a table or array"))?; + _x => { + return Err(err("expected `args` to be a table or array")) + .with_range( + &maybe_span(spans, "args").unwrap_or(args_pos.clone()), + )?; } }; @@ -289,7 +304,8 @@ pub(crate) fn regularize_commands( _ => { return Err(err( "`commands` to be an array that includes objects and strings only", - ))?; + )) + .with_range(&commands_span)?; } }; command_result.push(Command { diff --git a/src/rust/parsing/src/bind/prefix.rs b/src/rust/parsing/src/bind/prefix.rs index b37ba5d4..e2bac2d7 100644 --- a/src/rust/parsing/src/bind/prefix.rs +++ b/src/rust/parsing/src/bind/prefix.rs @@ -15,11 +15,11 @@ pub enum PrefixInput { Any(TypedValue), } -impl Default for PrefixInput { - fn default() -> Self { - return PrefixInput::Any(TypedValue::Constant(false)); - } -} +// impl Default for PrefixInput { +// fn default() -> Self { +// return PrefixInput::Any(TypedValue::Constant(false)); +// } +// } #[derive(Serialize, Clone, Debug)] pub enum Prefix { diff --git a/src/rust/parsing/src/bind/validation.rs b/src/rust/parsing/src/bind/validation.rs index 8185ee73..90ef6d5f 100644 --- a/src/rust/parsing/src/bind/validation.rs +++ b/src/rust/parsing/src/bind/validation.rs @@ -245,12 +245,12 @@ impl TryFrom for BindingReference { )) } else { Err(err( - "binding reference (must be of the form `{{bind.[identifier]}}`".into(), + "default must be of the form `{{bind.[identifier]}}`".into() ))? } } _ => Err(err( - "binding reference (must be of the form `{{bind.[identifier]}}`".into(), + "default must be of the form `{{bind.[identifier]}}`".into() ))?, } } diff --git a/src/rust/parsing/src/define.rs b/src/rust/parsing/src/define.rs index ff0069d8..eb72e3de 100644 --- a/src/rust/parsing/src/define.rs +++ b/src/rust/parsing/src/define.rs @@ -43,6 +43,10 @@ pub struct DefineInput { /// [expressions](/expressions/index) /// evaluated at runtime and in [when clauses](/bindings/bind#available-when-contexts). /// + /// Expressions can occur within the values, and these will be evaluated at read-time. + /// No `val.` fields are in scope within these expressions (i.e. you cannot refer to + /// one `define.val` key within the expression of a second `define.val` key). + /// /// ### Example /// /// A common command pattern in Larkin is to allow multiple lines to be selected using a @@ -200,9 +204,21 @@ impl Define { for def_block in input.val.into_iter().flatten() { for (val, value) in def_block.into_iter() { + let span = value.span().clone(); match value.resolve("`define.val`", scope) { - Ok(x) => { - resolved_var.insert(val, x); + Ok::(x) => { + match x.require_constant().with_range(&span) { + Ok(()) => { + resolved_var.insert(val, x); + } + Err(_) => { + // if the value wasn't constant at this point it is + // because we failed to evaluate the expression, + // (in a call to `scope.expand`), so we avoid registering + // the error twice + () + } + }; } Err(mut e) => { errors.append(&mut e.errors); @@ -279,7 +295,6 @@ impl Define { pub fn add_to_scope(&self, scope: &mut Scope) -> ResultVec<()> { let mut val = rhai::Map::new(); for (k, v) in self.val.iter() { - v.require_constant()?; let item: Dynamic = v.clone().into(); val.insert(k.into(), item); } @@ -293,7 +308,7 @@ impl Define { let BindingReference(name) = default.as_ref(); let entry = self.bind.entry(name.clone()); let occupied_entry = match entry { - hash_map::Entry::Vacant(_) => Err(err!("{name}"))?, + hash_map::Entry::Vacant(_) => Err(err!("undefined value `bind.{name}`"))?, hash_map::Entry::Occupied(entry) => entry, }; let mut default_value; diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index 6d0387b1..eb384739 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -23,6 +23,8 @@ use crate::bind::UNKNOWN_RANGE; #[derive(Debug, Error, Clone)] pub enum RawError { + #[error("previously reported error")] + RepeatError, #[error("conversion error: {0}")] IntError(#[from] std::num::TryFromIntError), #[error("while parsing toml: {0}")] @@ -380,7 +382,7 @@ lazy_static! { impl ParseError { /// `report` is how we generate legible annotations /// of *.mk.toml file errors in typescript - pub fn report(&self, content: &[u8]) -> ErrorReport { + pub fn report(&self, content: &[u8]) -> Option { let offsets: StringOffsets = StringOffsets::from_bytes(content); let mut message_buf = String::new(); let mut range = UNKNOWN_RANGE; @@ -398,6 +400,7 @@ impl ParseError { let msg = LINE_MESSAGE.replace_all(&raw_msg, ""); message_buf.push_str(&msg); } + RawError::RepeatError => return None, _ => { let raw_msg = &self.error.to_string(); let msg = LINE_MESSAGE.replace_all(&raw_msg, ""); @@ -444,20 +447,20 @@ impl ParseError { let pos = range_to_pos(&ref_range, &offsets); message_buf.push_str(&format!("{pos}")); }; - return ErrorReport { + return Some(ErrorReport { message: message_buf, range: cl_range, level: self.level.clone(), - }; + }); } else { - return ErrorReport { + return Some(ErrorReport { message: format!( "Failed to find range location for the message {}", message_buf ), range: CharRange::default(), level: ErrorLevel::Error, - }; + }); } } } @@ -465,7 +468,13 @@ impl ParseError { #[wasm_bindgen] impl ErrorSet { pub fn report(&self, content: &[u8]) -> Vec { - return self.errors.iter().map(|e| e.report(content)).collect(); + return self + .errors + .iter() + .map(|e| e.report(content)) + .filter(Option::is_some) + .map(Option::unwrap) + .collect(); } } diff --git a/src/rust/parsing/src/expression.rs b/src/rust/parsing/src/expression.rs index 38f3a84b..2fe0d509 100644 --- a/src/rust/parsing/src/expression.rs +++ b/src/rust/parsing/src/expression.rs @@ -5,15 +5,17 @@ pub mod value; #[allow(unused_imports)] use log::info; -use std::collections::{HashMap, HashSet, VecDeque}; - +use log::error; use rhai::Dynamic; use serde::Serialize; +use std::collections::{HashMap, HashSet, VecDeque}; use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ - bind::command::Command, bind::foreach::expression_fn__keys, err, error::ErrorContext, - error::Result, error::ResultVec, expression::value::Expanding, expression::value::Value, + bind::{command::Command, foreach::expression_fn__keys}, + err, + error::{ErrorContext, RawError, Result, ResultVec}, + expression::value::{Expanding, Value}, }; /// @file expressions/index.md @@ -140,24 +142,35 @@ impl Scope { self.state.set_or_push(k, v.clone()); } return Ok(obj.clone().map_expressions(&mut |expr| { - let ast = &self.asts[&expr.content]; - - let rewind_to = self.state.len(); - for (k, v) in &expr.scope { - let val: Dynamic = From::::from(Value::new(v.clone(), None)?); - self.state.push_dynamic(k, val); + if let Some(_) = expr.error { + // errors stored int he expression are raised in `parse_asts` which must be + // run before `expand`, so we can safely call this a repeat error + return Err(RawError::RepeatError.into()); + } + if let Some(ast) = self.asts.get(&expr.content) { + let rewind_to = self.state.len(); + for (k, v) in &expr.scope { + let val: Dynamic = From::::from(Value::new(v.clone(), None)?); + self.state.push_dynamic(k, val); + } + let dynamic: Dynamic = self + .engine + .eval_ast_with_scope(&mut self.state, ast) + .with_message(format!(" while evaluating {expr}")) + .with_exp_range(&expr.span)?; + self.state.rewind(rewind_to); + let result_value: std::result::Result = dynamic.clone().try_into(); + let value = result_value + .with_message(format!(" while evaluating {expr}")) + .with_exp_range(&expr.span)?; + return Ok(value); + } else { + // if the ast element doesn't exist this is *probably* because it failed to + // compile. If so, we've already generated an error. If not, it's a bug. So + // we log the problem, but do not report the issue through error handling. + error!("No ast defined for expression: {}", expr); + return Err(RawError::RepeatError.into()); } - let dynamic: Dynamic = self - .engine - .eval_ast_with_scope(&mut self.state, ast) - .with_message(format!(" while evaluating {expr}")) - .with_exp_range(&expr.span)?; - self.state.rewind(rewind_to); - let result_value: std::result::Result = dynamic.clone().try_into(); - let value = result_value - .with_message(format!(" while evaluating {expr}")) - .with_exp_range(&expr.span)?; - return Ok(value); })?); } diff --git a/src/rust/parsing/src/expression/value.rs b/src/rust/parsing/src/expression/value.rs index f43b894f..4a8661de 100644 --- a/src/rust/parsing/src/expression/value.rs +++ b/src/rust/parsing/src/expression/value.rs @@ -359,7 +359,6 @@ fn string_to_expression(x: String, span: Option>) -> Result // there are multiple expressions interpolated into the string let mut interps = Vec::new(); let mut last_match = 0..0; - // TODO: check for unmatched `{{` or `}}` // push rest for expr in exprs { let r = expr.get(0).expect("full match").range(); @@ -411,37 +410,37 @@ fn interp_to_string(interps: Vec) -> String { // ---------------- Value: Conversion ---------------- // -impl TryFrom for BareValue { - type Error = ErrorSet; - fn try_from(value: toml::Value) -> ResultVec { - return Ok(match value { - toml::Value::Boolean(x) => BareValue::Boolean(x), - toml::Value::Float(x) => BareValue::Float(x), - toml::Value::Integer(x) => BareValue::Integer({ - if i32::try_from(x).is_ok() { - x as i32 - } else { - Err(err("i64 value was too large (must fit in i32)"))?; - 0 - } - }), - toml::Value::Datetime(x) => BareValue::String(x.to_string()), - toml::Value::String(x) => BareValue::String(x), - toml::Value::Array(toml_values) => { - let values = flatten_errors(toml_values.into_iter().map(|x| { - return Ok(x.try_into::()?); - }))?; - BareValue::Array(values) - } - toml::Value::Table(toml_kv) => { - let kv = flatten_errors(toml_kv.into_iter().map(|(k, v)| { - Ok((k, Spanned::new(UNKNOWN_RANGE, v.try_into::()?))) - }))?; - BareValue::Table(kv.into_iter().collect()) - } - }); - } -} +// impl TryFrom for BareValue { +// type Error = ErrorSet; +// fn try_from(value: toml::Value) -> ResultVec { +// return Ok(match value { +// toml::Value::Boolean(x) => BareValue::Boolean(x), +// toml::Value::Float(x) => BareValue::Float(x), +// toml::Value::Integer(x) => BareValue::Integer({ +// if i32::try_from(x).is_ok() { +// x as i32 +// } else { +// Err(err("i64 value was too large (must fit in i32)"))?; +// 0 +// } +// }), +// toml::Value::Datetime(x) => BareValue::String(x.to_string()), +// toml::Value::String(x) => BareValue::String(x), +// toml::Value::Array(toml_values) => { +// let values = flatten_errors(toml_values.into_iter().map(|x| { +// return Ok(x.try_into::()?); +// }))?; +// BareValue::Array(values) +// } +// toml::Value::Table(toml_kv) => { +// let kv = flatten_errors(toml_kv.into_iter().map(|(k, v)| { +// Ok((k, Spanned::new(UNKNOWN_RANGE, v.try_into::()?))) +// }))?; +// BareValue::Table(kv.into_iter().collect()) +// } +// }); +// } +// } impl From for BareValue { fn from(value: Value) -> BareValue { @@ -658,8 +657,9 @@ pub trait Expanding { where Self: Sized + Clone, { - self.clone() - .map_expressions(&mut |e| Err(err!("Unresolved expression {e}"))?)?; + self.clone().map_expressions(&mut |e| { + Err(err!("Unresolved expression {e}")).with_range(&e.span)? + })?; return Ok(()); } } @@ -1093,4 +1093,30 @@ mod tests { Err(_) => return, }; } + + #[test] + #[should_panic] + fn unresolved_expression_to_toml_panics() { + let data = r#" + value = '{{1+2}}' + "#; + let value: std::result::Result = toml::from_str(data); + match value { + Ok(x) => toml::Value::from(x), + Err(_) => return, + }; + } + + #[test] + #[should_panic] + fn unresolved_interp_to_toml_panics() { + let data = r#" + value = 'joe {{1+2}} bob' + "#; + let value: std::result::Result = toml::from_str(data); + match value { + Ok(x) => toml::Value::from(x), + Err(_) => return, + }; + } } diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index 0fe6ffe5..f217e306 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -188,13 +188,30 @@ impl KeyFile { } // [[define]] - let define_input = input.define.unwrap_or_default(); - let mut define = match Define::new(define_input, &mut scope, warnings) { + let mut define_input = input.define.unwrap_or_default(); + let mut skip_define = false; + let _ = scope + .parse_asts(&define_input.val) + .map_err(|mut es| errors.append(&mut es.errors)); + match scope.expand(&define_input.val) { + Ok(x) => { + define_input.val = x; + } Err(mut es) => { + skip_define = true; errors.append(&mut es.errors); - Define::default() } - Ok(x) => x, + }; + let mut define = if !skip_define { + match Define::new(define_input, &mut scope, warnings) { + Err(mut es) => { + errors.append(&mut es.errors); + Define::default() + } + Ok(x) => x, + } + } else { + Define::default() }; // [[mode]] @@ -213,11 +230,13 @@ impl KeyFile { let kind = Kind::process(&input.kind, &mut scope, warnings)?; // [[bind]] - let input_iter = input - .bind - .into_iter() - .flatten() - .map(|x| Ok(Spanned::new(x.span(), define.expand(x.into_inner())?))); + let input_iter = input.bind.into_iter().flatten().map(|x| { + let span = x.span().clone(); + return Ok(Spanned::new( + span.clone(), + define.expand(x.into_inner()).with_range(&span)?, + )); + }); let bind_input = match flatten_errors(input_iter) { Err(mut es) => { @@ -326,7 +345,14 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { return match result { Ok(result) => KeyFileResult { file: Some(result), - errors: Some(warnings.iter().map(|e| e.report(&file_content)).collect()), + errors: Some( + warnings + .iter() + .map(|e| e.report(&file_content)) + .filter(Option::is_some) + .map(Option::unwrap) + .collect(), + ), }, Err(err) => KeyFileResult { file: None, @@ -335,6 +361,8 @@ pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { .iter() .chain(warnings.iter()) .map(|e| e.report(&file_content)) + .filter(Option::is_some) + .map(Option::unwrap) .collect(), ), }, @@ -376,24 +404,9 @@ fn parse_bytes_helper(file_content: &[u8], warnings: &mut Vec) -> Re let parsed = toml::from_slice::(file_content)?; - let mut scope = Scope::new(); // TODO: do something with this scope?? - let bind = parsed.bind.clone(); + let mut scope = Scope::new(); // TODO: do something with this scope?? (don't we need this state somewhere?) let result = KeyFile::new(parsed, &mut scope, warnings); - let legacy_check = bind.map_expressions(&mut |ex @ Expression { .. }| { - if OLD_EXPRESSION.is_match(&ex.content) { - Err(wrn!( - "In format 2.0, expressions must now be surrounded in double curly\ - braces, not single.", - )) - .with_range(&ex.span.clone())?; - } - return Ok(Value::Exp(ex)); - }); - match legacy_check { - Err(mut e) => warnings.append(&mut e.errors), - Ok(_) => (), - }; return result; } @@ -448,7 +461,14 @@ pub fn identify_legacy_warnings(file_content: Box<[u8]>) -> KeyFileResult { }, Err(e) => KeyFileResult { file: None, - errors: Some(e.errors.iter().map(|x| x.report(&file_content)).collect()), + errors: Some( + e.errors + .iter() + .map(|x| x.report(&file_content)) + .filter(Option::is_some) + .map(Option::unwrap) + .collect(), + ), }, }; } @@ -507,6 +527,25 @@ pub(crate) mod tests { assert_eq!(result.bind[1].commands[0].command, "cursorLeft"); } + #[test] + fn bad_toml_raises_error() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[define.val + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); + let report = result.report(data.as_bytes()); + assert!(report[0].message.contains("expected `]]`")); + assert_eq!(report[0].range.start.line, 6); + assert_eq!(report[0].range.end.line, 6); + } + #[test] fn validate_version() { let data = r#" @@ -549,6 +588,26 @@ pub(crate) mod tests { assert_eq!(report[0].range.start.line, 0); } + #[test] + fn legacy_expression_warning() { + let data = r#" + #:master-keybindings + [header] + version = "2.0.0" + + [[bind]] + foreach.key = ['{key: [0-9]}'] + key = "a" + command = "foo{key}" + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + // let report = err.report(data.as_bytes()); + info!("warnings: {warnings:#?}"); + info!("result: {result:#?}"); + } + #[test] fn resolve_bind_and_command() { let data = r#" @@ -763,7 +822,6 @@ pub(crate) mod tests { &mut warnings, ); let report = result.unwrap_err().report(data.as_bytes()); - info!("reprot: {report:#?}"); assert!(report[0].message.contains("regex parse error")); assert!(!report[0].message.contains("(line")); assert_eq!(report[0].range.start.line, 5); @@ -778,6 +836,7 @@ pub(crate) mod tests { [[define.val]] foo = "bar" + biz = '{{"baz" + "_biz"}}' [[bind]] key = "x" @@ -794,6 +853,10 @@ pub(crate) mod tests { ) .unwrap(); assert_eq!(result.bind[0].commands[0].command, "bar"); + assert_eq!( + result.define.val["biz"], + Value::String("baz_biz".to_string()) + ) } #[test] @@ -1596,7 +1659,7 @@ pub(crate) mod tests { let err = toml::from_str::(data).unwrap_err(); let err: ParseError = err.into(); - let report = err.report(data.as_bytes()); + let report = err.report(data.as_bytes()).unwrap(); assert!(report.message.contains("invalid modifier")); assert_eq!(report.range.start.line, 6); assert_eq!(report.range.end.line, 6); @@ -1617,7 +1680,7 @@ pub(crate) mod tests { let err = toml::from_str::(data).unwrap_err(); let err: ParseError = err.into(); - let report = err.report(data.as_bytes()); + let report = err.report(data.as_bytes()).unwrap(); assert!(report.message.contains("invalid key")); assert_eq!(report.range.start.line, 6); assert_eq!(report.range.end.line, 6); @@ -1674,6 +1737,329 @@ pub(crate) mod tests { assert_eq!(report[0].range.end.col, 23); } + // TODO: something is up with how this is being parsed... 🤔 + + #[test] + fn expression_error_val() { + let data = r#" + [header] + version = "2.0.0" + + [[define.val]] + x = "1+2}}" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); + + let report = err.report(data.as_bytes()); + assert_eq!(report[0].message, "unexpected `}}`"); + assert_eq!(report[0].range.start.line, 5); + assert_eq!(report[0].range.end.line, 5); + assert_eq!(report[0].range.start.col, 12); + assert_eq!(report[0].range.end.col, 19); + } + + #[test] + fn define_command_error() { + let data = r#" + [header] + version = "2.0.0" + + [[define.command]] + args.value = 2 + "#; + + let err = toml::from_str::(data).unwrap_err(); + let err: ParseError = err.into(); + let report = err.report(data.as_bytes()).unwrap(); + assert_eq!(report.range.start.line, 4); + assert_eq!(report.range.end.line, 4); + } + + #[test] + fn define_bind_error() { + let data = r#" + [header] + version = "2.0.0" + + [[define.bind]] + key = "xyz" + "#; + + let err = toml::from_str::(data).unwrap_err(); + let err: ParseError = err.into(); + let report = err.report(data.as_bytes()).unwrap(); + assert_eq!(report.range.start.line, 5); + assert_eq!(report.range.end.line, 5); + } + + #[test] + fn default_is_undefined() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "foo" + default = "{{bind.foo}}" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); + + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("undefined value")); + assert_eq!(report[0].range.start.line, 4); + assert_eq!(report[0].range.end.line, 4); + } + + #[test] + fn bind_reference_misplaced() { + let data = r#" + [header] + version = "2.0.0" + + [[define.bind]] + id = "foo" + doc.name = "foo" + + [[bind]] + key = "{{bind.foo}}" + command = "bar" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); + + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("unexpected `bind.`")); + assert_eq!(report[0].range.start.line, 9); + assert_eq!(report[0].range.end.line, 9); + } + + #[test] + fn expression_error_points_to_line() { + let data = r#" + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "foo" + finalKey = "{{(1+2}}" + doc.name = "{{(2+3}}" + doc.combined.name = "{{(3+4}}" + "#; + + let mut scope = Scope::new(); + let mut warnings = Vec::new(); + let err = KeyFile::new( + toml::from_str::(data).unwrap(), + &mut scope, + &mut warnings, + ) + .unwrap_err(); + + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("Expecting ')'")); + assert_eq!(report[0].range.start.line, 7); + assert_eq!(report[0].range.end.line, 7); + assert!(report[1].message.contains("Expecting ')'")); + assert_eq!(report[1].range.start.line, 8); + assert_eq!(report[1].range.end.line, 8); + assert!(report[2].message.contains("Expecting ')'")); + assert_eq!(report[2].range.start.line, 9); + assert_eq!(report[2].range.end.line, 9); + } + + #[test] + fn require_unique_kind_names() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[kind]] + name = "biz" + description = "buzz" + + [[kind]] + name = "biz" + description = "beep" + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`name` must be unique")); + assert_eq!(report[0].range.start.line, 10); + assert_eq!(report[0].range.end.line, 10); + } + + #[test] + fn run_commands_needs_table() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + args = [1,2,3] + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`args`")); + assert_eq!(report[0].range.start.line, 6); + assert_eq!(report[0].range.end.line, 6); + } + + #[test] + fn run_commands_needs_commands_array() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + args.commands.x = 1 + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`args.commands`")); + assert_eq!(report[0].range.start.line, 9); + assert_eq!(report[0].range.end.line, 9); + } + + #[test] + fn run_commands_needs_string_command() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + + [[bind.args.commands]] + command = 2 + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`command`")); + assert_eq!(report[0].range.start.line, 11); + assert_eq!(report[0].range.end.line, 11); + } + + #[test] + fn run_commands_no_nested_in_skipwhen() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + + [[bind.args.commands]] + command = "runCommands" + skipWhen = '{key.mode == "normal"}' + args.commands = ["a", "b"] + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`skipWhen`")); + assert_eq!(report[0].range.start.line, 12); + assert_eq!(report[0].range.end.line, 12); + } + + #[test] + fn run_commands_args_table_or_array() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + + [[bind.args.commands]] + command = "foo" + args = 2 + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`args`")); + assert_eq!(report[0].range.start.line, 12); + assert_eq!(report[0].range.end.line, 12); + } + + #[test] + fn run_commands_commands_args_has_objects_and_strings_only() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + key = "a" + command = "runCommands" + args.commands = ["a", 1] + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`commands`")); + assert_eq!(report[0].range.start.line, 9); + assert_eq!(report[0].range.end.line, 9); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index 0a62dcbc..dde0d80b 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -27,21 +27,21 @@ pub trait Merging { fn merge(self, new: Self) -> Self; } -impl Merging for toml::Table { - fn coalesce(self, new: Self) -> Self { - return new; - } - // BUG!!!: we need to add the new keys that aren't in self to `pairs` - fn merge(self, new: Self) -> Self { - let (mut to_merge, to_append): (toml::Table, toml::Table) = - new.into_iter().partition(|(k, _)| self.get(k).is_some()); - let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { - Some(new_v) => (k, v.merge(new_v)), - Option::None => (k, v), - }); - return pairs.chain(to_append.into_iter()).collect(); - } -} +// impl Merging for toml::Table { +// fn coalesce(self, new: Self) -> Self { +// return new; +// } +// // BUG!!!: we need to add the new keys that aren't in self to `pairs` +// fn merge(self, new: Self) -> Self { +// let (mut to_merge, to_append): (toml::Table, toml::Table) = +// new.into_iter().partition(|(k, _)| self.get(k).is_some()); +// let pairs = self.into_iter().map(|(k, v)| match to_merge.remove(&k) { +// Some(new_v) => (k, v.merge(new_v)), +// Option::None => (k, v), +// }); +// return pairs.chain(to_append.into_iter()).collect(); +// } +// } impl Merging for HashMap { fn coalesce(self, new: Self) -> Self { @@ -182,44 +182,44 @@ impl Merging for String { } } -impl Merging for toml::Value { - fn coalesce(self, new: Self) -> Self { - return new; - } - fn merge(self, new: Self) -> Self { - match new { - Value::Array(new_values) => match self { - Value::Array(old_values) => { - let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); - let mut new_iter = new_values.iter(); - let mut old_iter = old_values.iter(); - loop { - let new_item = new_iter.next(); - let old_item = old_iter.next(); - if let Some(new_val) = new_item { - if let Some(old_val) = old_item { - result.push(old_val.clone().merge(new_val.clone())); - } else { - result.push(new_val.clone()); - } - } else if let Some(old_val) = old_item { - result.push(old_val.clone()); - } else { - break; - } - } - Value::Array(result) - } - _ => Value::Array(new_values), - }, - Value::Table(new_kv) => match self { - Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), - _ => Value::Table(new_kv), - }, - _ => new, - } - } -} +// impl Merging for toml::Value { +// fn coalesce(self, new: Self) -> Self { +// return new; +// } +// fn merge(self, new: Self) -> Self { +// match new { +// Value::Array(new_values) => match self { +// Value::Array(old_values) => { +// let mut result = Vec::with_capacity(new_values.len().max(old_values.len())); +// let mut new_iter = new_values.iter(); +// let mut old_iter = old_values.iter(); +// loop { +// let new_item = new_iter.next(); +// let old_item = old_iter.next(); +// if let Some(new_val) = new_item { +// if let Some(old_val) = old_item { +// result.push(old_val.clone().merge(new_val.clone())); +// } else { +// result.push(new_val.clone()); +// } +// } else if let Some(old_val) = old_item { +// result.push(old_val.clone()); +// } else { +// break; +// } +// } +// Value::Array(result) +// } +// _ => Value::Array(new_values), +// }, +// Value::Table(new_kv) => match self { +// Value::Table(old_kv) => Value::Table(old_kv.merge(new_kv)), +// _ => Value::Table(new_kv), +// }, +// _ => new, +// } +// } +// } // // ---------------- Subset ---------------- From 91d6bdb34c4953f2aca03389bda3483af80768d2 Mon Sep 17 00:00:00 2001 From: David Little Date: Fri, 17 Oct 2025 17:24:52 -0400 Subject: [PATCH 77/79] removed errant profile txt file Created using spr 1.3.6-beta.1 --- .../CPU-20251014T121114.750Z.cpuprofile.txt | 93047 ---------------- 1 file changed, 93047 deletions(-) delete mode 100644 src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt diff --git a/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt b/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt deleted file mode 100644 index 2c0c1817..00000000 --- a/src/rust/parsing/src/CPU-20251014T121114.750Z.cpuprofile.txt +++ /dev/null @@ -1,93047 +0,0 @@ -{ - "nodes": [ - { - "id": 1, - "callFrame": { - "functionName": "(root)", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 0, - "children": [ - 2, - 3, - 8, - 9, - 10, - 61, - 72, - 92, - 115, - 123, - 139, - 142, - 148, - 170, - 172, - 175, - 215, - 217, - 246, - 255, - 276, - 291, - 314, - 317, - 327, - 334, - 337, - 346, - 347, - 354, - 355, - 394, - 397, - 398, - 423, - 426, - 428, - 470, - 473, - 504, - 510, - 546, - 557, - 563, - 564, - 579, - 590, - 595, - 599, - 641, - 708, - 712, - 717, - 758 - ] - }, - { - "id": 2, - "callFrame": { - "functionName": "(program)", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1060 - }, - { - "id": 3, - "callFrame": { - "functionName": "r", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 239, - "columnNumber": 935 - }, - "hitCount": 219, - "children": [ - 4, - 486 - ], - "positionTicks": [ - { - "line": 240, - "ticks": 22 - }, - { - "line": 240, - "ticks": 135 - }, - { - "line": 240, - "ticks": 1 - }, - { - "line": 240, - "ticks": 61 - } - ] - }, - { - "id": 4, - "callFrame": { - "functionName": "re", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8649 - }, - "hitCount": 267, - "children": [ - 5 - ], - "positionTicks": [ - { - "line": 222, - "ticks": 4 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 2 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 28, - "ticks": 4 - }, - { - "line": 228, - "ticks": 3 - }, - { - "line": 222, - "ticks": 5 - }, - { - "line": 222, - "ticks": 2 - }, - { - "line": 228, - "ticks": 3 - }, - { - "line": 222, - "ticks": 6 - }, - { - "line": 222, - "ticks": 11 - }, - { - "line": 222, - "ticks": 26 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 18 - }, - { - "line": 222, - "ticks": 10 - }, - { - "line": 222, - "ticks": 4 - }, - { - "line": 228, - "ticks": 9 - }, - { - "line": 228, - "ticks": 9 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 10 - }, - { - "line": 222, - "ticks": 7 - }, - { - "line": 222, - "ticks": 15 - }, - { - "line": 222, - "ticks": 8 - }, - { - "line": 222, - "ticks": 6 - }, - { - "line": 28, - "ticks": 10 - }, - { - "line": 222, - "ticks": 5 - }, - { - "line": 222, - "ticks": 15 - }, - { - "line": 222, - "ticks": 47 - }, - { - "line": 222, - "ticks": 13 - } - ] - }, - { - "id": 5, - "callFrame": { - "functionName": "parse", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 21964 - }, - "hitCount": 2157, - "children": [ - 6, - 7 - ], - "positionTicks": [ - { - "line": 222, - "ticks": 2 - }, - { - "line": 222, - "ticks": 2155 - } - ] - }, - { - "id": 6, - "callFrame": { - "functionName": "ko", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 24025 - }, - "hitCount": 1849, - "positionTicks": [ - { - "line": 222, - "ticks": 1849 - } - ] - }, - { - "id": 7, - "callFrame": { - "functionName": "Bc", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 20641 - }, - "hitCount": 640, - "positionTicks": [ - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 5 - }, - { - "line": 222, - "ticks": 6 - }, - { - "line": 222, - "ticks": 4 - }, - { - "line": 222, - "ticks": 2 - }, - { - "line": 222, - "ticks": 17 - }, - { - "line": 222, - "ticks": 7 - }, - { - "line": 222, - "ticks": 483 - }, - { - "line": 222, - "ticks": 33 - }, - { - "line": 222, - "ticks": 3 - }, - { - "line": 222, - "ticks": 19 - }, - { - "line": 222, - "ticks": 15 - }, - { - "line": 222, - "ticks": 2 - }, - { - "line": 222, - "ticks": 24 - }, - { - "line": 222, - "ticks": 5 - }, - { - "line": 222, - "ticks": 12 - } - ] - }, - { - "id": 486, - "callFrame": { - "functionName": "Bc", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 20641 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 222, - "ticks": 1 - } - ] - }, - { - "id": 8, - "callFrame": { - "functionName": "refresh", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 234, - "columnNumber": 875 - }, - "hitCount": 121, - "children": [ - 171 - ], - "positionTicks": [ - { - "line": 235, - "ticks": 121 - } - ] - }, - { - "id": 171, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 234, - "columnNumber": 918 - }, - "hitCount": 17, - "positionTicks": [ - { - "line": 235, - "ticks": 1 - }, - { - "line": 235, - "ticks": 6 - }, - { - "line": 235, - "ticks": 10 - } - ] - }, - { - "id": 9, - "callFrame": { - "functionName": "(idle)", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 8172 - }, - { - "id": 10, - "callFrame": { - "functionName": "onStreamRead", - "scriptId": "113", - "url": "node:internal/stream_base_commons", - "lineNumber": 165, - "columnNumber": 21 - }, - "hitCount": 13, - "children": [ - 11, - 19, - 500, - 544, - 547, - 549, - 558, - 580, - 644 - ], - "positionTicks": [ - { - "line": 166, - "ticks": 13 - } - ] - }, - { - "id": 11, - "callFrame": { - "functionName": "Readable.push", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 386, - "columnNumber": 34 - }, - "hitCount": 0, - "children": [ - 12 - ] - }, - { - "id": 12, - "callFrame": { - "functionName": "readableAddChunkPushByteMode", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 462, - "columnNumber": 37 - }, - "hitCount": 0, - "children": [ - 13 - ] - }, - { - "id": 13, - "callFrame": { - "functionName": "onEofChunk", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 787, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 14 - ] - }, - { - "id": 14, - "callFrame": { - "functionName": "emitReadable_", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 829, - "columnNumber": 22 - }, - "hitCount": 0, - "children": [ - 15 - ] - }, - { - "id": 15, - "callFrame": { - "functionName": "Socket.read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 779, - "columnNumber": 32 - }, - "hitCount": 0, - "children": [ - 16 - ] - }, - { - "id": 16, - "callFrame": { - "functionName": "Readable.read", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 646, - "columnNumber": 34 - }, - "hitCount": 0, - "children": [ - 17 - ] - }, - { - "id": 17, - "callFrame": { - "functionName": "endReadable", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1681, - "columnNumber": 20 - }, - "hitCount": 0, - "children": [ - 18 - ] - }, - { - "id": 18, - "callFrame": { - "functionName": "nextTick", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 112, - "columnNumber": 17 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 139, - "ticks": 1 - }, - { - "line": 137, - "ticks": 1 - }, - { - "line": 135, - "ticks": 1 - } - ] - }, - { - "id": 19, - "callFrame": { - "functionName": "readableAddChunkPushByteMode", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 462, - "columnNumber": 37 - }, - "hitCount": 5, - "children": [ - 20, - 645 - ], - "positionTicks": [ - { - "line": 530, - "ticks": 2 - }, - { - "line": 477, - "ticks": 3 - } - ] - }, - { - "id": 20, - "callFrame": { - "functionName": "addChunk", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 549, - "columnNumber": 17 - }, - "hitCount": 0, - "children": [ - 21, - 311 - ] - }, - { - "id": 21, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 1, - "children": [ - 22, - 391, - 731 - ], - "positionTicks": [ - { - "line": 519, - "ticks": 1 - } - ] - }, - { - "id": 22, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 1152 - }, - "hitCount": 71, - "children": [ - 23, - 377 - ], - "positionTicks": [ - { - "line": 136, - "ticks": 71 - } - ] - }, - { - "id": 23, - "callFrame": { - "functionName": "s", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 703 - }, - "hitCount": 31, - "children": [ - 24, - 551, - 584 - ], - "positionTicks": [ - { - "line": 136, - "ticks": 31 - } - ] - }, - { - "id": 24, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 133, - "columnNumber": 107 - }, - "hitCount": 1715, - "children": [ - 25, - 30 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 136, - "ticks": 1 - }, - { - "line": 135, - "ticks": 5 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 136, - "ticks": 2 - }, - { - "line": 136, - "ticks": 2 - }, - { - "line": 136, - "ticks": 1 - }, - { - "line": 136, - "ticks": 3 - }, - { - "line": 136, - "ticks": 4 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 224 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 136, - "ticks": 1 - }, - { - "line": 142, - "ticks": 3 - }, - { - "line": 136, - "ticks": 3 - }, - { - "line": 136, - "ticks": 3 - }, - { - "line": 136, - "ticks": 10 - }, - { - "line": 142, - "ticks": 21 - }, - { - "line": 136, - "ticks": 9 - }, - { - "line": 134, - "ticks": 3 - }, - { - "line": 136, - "ticks": 6 - }, - { - "line": 142, - "ticks": 21 - }, - { - "line": 142, - "ticks": 9 - }, - { - "line": 136, - "ticks": 14 - }, - { - "line": 27, - "ticks": 78 - }, - { - "line": 27, - "ticks": 224 - }, - { - "line": 27, - "ticks": 66 - }, - { - "line": 136, - "ticks": 8 - }, - { - "line": 27, - "ticks": 829 - }, - { - "line": 142, - "ticks": 4 - }, - { - "line": 142, - "ticks": 4 - }, - { - "line": 142, - "ticks": 1 - }, - { - "line": 27, - "ticks": 4 - }, - { - "line": 136, - "ticks": 7 - }, - { - "line": 142, - "ticks": 13 - }, - { - "line": 142, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 134, - "ticks": 1 - }, - { - "line": 134, - "ticks": 121 - } - ] - }, - { - "id": 25, - "callFrame": { - "functionName": "Md", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 91870 - }, - "hitCount": 0, - "children": [ - 26 - ] - }, - { - "id": 26, - "callFrame": { - "functionName": "JS", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 91989 - }, - "hitCount": 539, - "children": [ - 27, - 64 - ], - "positionTicks": [ - { - "line": 8, - "ticks": 1 - }, - { - "line": 8, - "ticks": 1 - }, - { - "line": 8, - "ticks": 1 - }, - { - "line": 28, - "ticks": 536 - } - ] - }, - { - "id": 27, - "callFrame": { - "functionName": "set", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9960 - }, - "hitCount": 0, - "children": [ - 28, - 69 - ] - }, - { - "id": 28, - "callFrame": { - "functionName": "set", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9799 - }, - "hitCount": 0, - "children": [ - 29 - ] - }, - { - "id": 29, - "callFrame": { - "functionName": "set", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 6305 - }, - "hitCount": 12, - "positionTicks": [ - { - "line": 8, - "ticks": 5 - }, - { - "line": 8, - "ticks": 7 - } - ] - }, - { - "id": 69, - "callFrame": { - "functionName": "q", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9835 - }, - "hitCount": 0, - "children": [ - 70 - ] - }, - { - "id": 70, - "callFrame": { - "functionName": "r", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9943 - }, - "hitCount": 0, - "children": [ - 71 - ] - }, - { - "id": 71, - "callFrame": { - "functionName": "h", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 7884 - }, - "hitCount": 100, - "positionTicks": [ - { - "line": 8, - "ticks": 100 - } - ] - }, - { - "id": 64, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9736 - }, - "hitCount": 0, - "children": [ - 65 - ] - }, - { - "id": 65, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 6233 - }, - "hitCount": 65, - "positionTicks": [ - { - "line": 8, - "ticks": 65 - } - ] - }, - { - "id": 30, - "callFrame": { - "functionName": "J", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 2880 - }, - "hitCount": 1, - "children": [ - 31, - 62 - ], - "positionTicks": [ - { - "line": 136, - "ticks": 1 - } - ] - }, - { - "id": 31, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 8601 - }, - "hitCount": 41, - "children": [ - 32 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 41 - } - ] - }, - { - "id": 32, - "callFrame": { - "functionName": "c", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5822 - }, - "hitCount": 0, - "children": [ - 33, - 35 - ] - }, - { - "id": 33, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5864 - }, - "hitCount": 862, - "children": [ - 34 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 862 - } - ] - }, - { - "id": 34, - "callFrame": { - "functionName": "j", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 6345 - }, - "hitCount": 3576, - "children": [ - 63 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 3 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 142, - "ticks": 3 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 142, - "ticks": 2 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 4 - }, - { - "line": 27, - "ticks": 3 - }, - { - "line": 27, - "ticks": 3 - }, - { - "line": 27, - "ticks": 17 - }, - { - "line": 27, - "ticks": 9 - }, - { - "line": 142, - "ticks": 8 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 142, - "ticks": 9 - }, - { - "line": 27, - "ticks": 5 - }, - { - "line": 27, - "ticks": 13 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 19 - }, - { - "line": 27, - "ticks": 4 - }, - { - "line": 27, - "ticks": 448 - }, - { - "line": 27, - "ticks": 4 - }, - { - "line": 27, - "ticks": 27 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 26 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 7 - }, - { - "line": 27, - "ticks": 3 - }, - { - "line": 27, - "ticks": 369 - }, - { - "line": 27, - "ticks": 387 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 26 - }, - { - "line": 27, - "ticks": 109 - }, - { - "line": 27, - "ticks": 362 - }, - { - "line": 27, - "ticks": 463 - }, - { - "line": 27, - "ticks": 107 - }, - { - "line": 27, - "ticks": 235 - }, - { - "line": 27, - "ticks": 447 - }, - { - "line": 142, - "ticks": 7 - }, - { - "line": 27, - "ticks": 430 - } - ] - }, - { - "id": 63, - "callFrame": { - "functionName": "join", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 18363 - }, - "hitCount": 354, - "children": [ - 368 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 9 - }, - { - "line": 27, - "ticks": 345 - } - ] - }, - { - "id": 368, - "callFrame": { - "functionName": "normalize", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 18105 - }, - "hitCount": 0, - "children": [ - 369 - ] - }, - { - "id": 369, - "callFrame": { - "functionName": "pd", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 10423 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 35, - "callFrame": { - "functionName": "s", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12027 - }, - "hitCount": 0, - "children": [ - 36, - 38 - ] - }, - { - "id": 36, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12075 - }, - "hitCount": 40, - "children": [ - 37 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 40 - } - ] - }, - { - "id": 37, - "callFrame": { - "functionName": "file", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 57791 - }, - "hitCount": 643, - "children": [ - 66 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 19 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 9 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 8 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 4 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 28, - "ticks": 532 - } - ] - }, - { - "id": 66, - "callFrame": { - "functionName": "Pa", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 58904 - }, - "hitCount": 0, - "children": [ - 67 - ] - }, - { - "id": 67, - "callFrame": { - "functionName": "Jm", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56907 - }, - "hitCount": 0, - "children": [ - 68, - 390 - ] - }, - { - "id": 68, - "callFrame": { - "functionName": "WM", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 55722 - }, - "hitCount": 132, - "positionTicks": [ - { - "line": 28, - "ticks": 78 - }, - { - "line": 28, - "ticks": 54 - } - ] - }, - { - "id": 390, - "callFrame": { - "functionName": "VM", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56421 - }, - "hitCount": 7, - "positionTicks": [ - { - "line": 28, - "ticks": 7 - } - ] - }, - { - "id": 38, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12365 - }, - "hitCount": 4, - "children": [ - 39, - 502 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 4 - } - ] - }, - { - "id": 39, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 1, - "children": [ - 40 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 40, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 16, - "children": [ - 41, - 43, - 53, - 577, - 743 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 2, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 12 - } - ] - }, - { - "id": 41, - "callFrame": { - "functionName": "serializeRequestArguments", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124548 - }, - "hitCount": 0, - "children": [ - 42 - ] - }, - { - "id": 42, - "callFrame": { - "functionName": "oE", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116912 - }, - "hitCount": 1474, - "children": [ - 333 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1474 - } - ] - }, - { - "id": 333, - "callFrame": { - "functionName": "toJSON", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 59147 - }, - "hitCount": 42, - "positionTicks": [ - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 9 - } - ] - }, - { - "id": 43, - "callFrame": { - "functionName": "serializeRequest", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124944 - }, - "hitCount": 2, - "children": [ - 44, - 310 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 44, - "callFrame": { - "functionName": "b", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 125054 - }, - "hitCount": 5, - "children": [ - 45, - 244, - 358, - 526, - 559, - 776 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 5 - } - ] - }, - { - "id": 45, - "callFrame": { - "functionName": "fromString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86344 - }, - "hitCount": 6, - "children": [ - 46 - ], - "positionTicks": [ - { - "line": 464, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 461, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 490, - "ticks": 1 - }, - { - "line": 463, - "ticks": 1 - } - ] - }, - { - "id": 46, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 47 - ] - }, - { - "id": 47, - "callFrame": { - "functionName": "fromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 479, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 48 - ] - }, - { - "id": 48, - "callFrame": { - "functionName": "fromStringFast", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 446, - "columnNumber": 23 - }, - "hitCount": 1, - "children": [ - 49, - 241, - 525 - ], - "positionTicks": [ - { - "line": 453, - "ticks": 1 - } - ] - }, - { - "id": 49, - "callFrame": { - "functionName": "createFromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 473, - "columnNumber": 25 - }, - "hitCount": 2, - "children": [ - 50, - 56, - 58 - ], - "positionTicks": [ - { - "line": 1099, - "ticks": 1 - }, - { - "line": 1095, - "ticks": 1 - } - ] - }, - { - "id": 50, - "callFrame": { - "functionName": "allocUnsafeSlow", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 416, - "columnNumber": 49 - }, - "hitCount": 0, - "children": [ - 51 - ] - }, - { - "id": 51, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 52 - ] - }, - { - "id": 52, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 148, - "positionTicks": [ - { - "line": 961, - "ticks": 148 - } - ] - }, - { - "id": 56, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1064, - "positionTicks": [ - { - "line": 474, - "ticks": 1064 - } - ] - }, - { - "id": 58, - "callFrame": { - "functionName": "write", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 634, - "columnNumber": 11 - }, - "hitCount": 2, - "children": [ - 59 - ], - "positionTicks": [ - { - "line": 635, - "ticks": 2 - } - ] - }, - { - "id": 59, - "callFrame": { - "functionName": "utf8Write", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1060, - "columnNumber": 38 - }, - "hitCount": 0, - "children": [ - 60 - ] - }, - { - "id": 60, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 75, - "positionTicks": [ - { - "line": 1068, - "ticks": 75 - } - ] - }, - { - "id": 241, - "callFrame": { - "functionName": "write", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 634, - "columnNumber": 11 - }, - "hitCount": 1, - "children": [ - 242 - ], - "positionTicks": [ - { - "line": 635, - "ticks": 1 - } - ] - }, - { - "id": 242, - "callFrame": { - "functionName": "utf8Write", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1060, - "columnNumber": 38 - }, - "hitCount": 0, - "children": [ - 243 - ] - }, - { - "id": 243, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 1068, - "ticks": 3 - } - ] - }, - { - "id": 525, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 961, - "ticks": 3 - } - ] - }, - { - "id": 244, - "callFrame": { - "functionName": "writeLongString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 122525 - }, - "hitCount": 0, - "children": [ - 245 - ] - }, - { - "id": 245, - "callFrame": { - "functionName": "set", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 87101 - }, - "hitCount": 36, - "positionTicks": [ - { - "line": 28, - "ticks": 36 - } - ] - }, - { - "id": 358, - "callFrame": { - "functionName": "alloc", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 121701 - }, - "hitCount": 2, - "children": [ - 359 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 359, - "callFrame": { - "functionName": "alloc", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86148 - }, - "hitCount": 0, - "children": [ - 360 - ] - }, - { - "id": 360, - "callFrame": { - "functionName": "allocUnsafe", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 406, - "columnNumber": 41 - }, - "hitCount": 0, - "children": [ - 361 - ] - }, - { - "id": 361, - "callFrame": { - "functionName": "allocate", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 431, - "columnNumber": 17 - }, - "hitCount": 1, - "children": [ - 362 - ], - "positionTicks": [ - { - "line": 444, - "ticks": 1 - } - ] - }, - { - "id": 362, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 363 - ] - }, - { - "id": 363, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 117, - "positionTicks": [ - { - "line": 961, - "ticks": 117 - } - ] - }, - { - "id": 526, - "callFrame": { - "functionName": "writeShortString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 122239 - }, - "hitCount": 0, - "children": [ - 527 - ] - }, - { - "id": 527, - "callFrame": { - "functionName": "set", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 87101 - }, - "hitCount": 4, - "positionTicks": [ - { - "line": 28, - "ticks": 4 - } - ] - }, - { - "id": 559, - "callFrame": { - "functionName": "write", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 634, - "columnNumber": 11 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 1061, - "ticks": 2 - } - ] - }, - { - "id": 776, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1094, - "ticks": 1 - } - ] - }, - { - "id": 310, - "callFrame": { - "functionName": "fromString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86344 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 28, - "ticks": 2 - } - ] - }, - { - "id": 53, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 54 - ] - }, - { - "id": 54, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 55 - ] - }, - { - "id": 55, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 615, - "children": [ - 57 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 615 - } - ] - }, - { - "id": 57, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 492, - "positionTicks": [ - { - "line": 2, - "ticks": 492 - } - ] - }, - { - "id": 577, - "callFrame": { - "functionName": "F", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 117946 - }, - "hitCount": 0, - "children": [ - 578 - ] - }, - { - "id": 578, - "callFrame": { - "functionName": "schedule", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 75636 - }, - "hitCount": 1, - "children": [ - 774 - ], - "positionTicks": [ - { - "line": 139, - "ticks": 1 - } - ] - }, - { - "id": 774, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 775 - ] - }, - { - "id": 775, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 743, - "callFrame": { - "functionName": "s3", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 24, - "columnNumber": 1332 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 25, - "ticks": 2 - } - ] - }, - { - "id": 502, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118418 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 62, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10259 - }, - "hitCount": 995, - "positionTicks": [ - { - "line": 107, - "ticks": 2 - }, - { - "line": 107, - "ticks": 4 - }, - { - "line": 107, - "ticks": 4 - }, - { - "line": 107, - "ticks": 4 - }, - { - "line": 107, - "ticks": 981 - } - ] - }, - { - "id": 551, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10259 - }, - "hitCount": 5, - "positionTicks": [ - { - "line": 107, - "ticks": 1 - }, - { - "line": 107, - "ticks": 4 - } - ] - }, - { - "id": 584, - "callFrame": { - "functionName": "file", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 57791 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 28, - "ticks": 2 - } - ] - }, - { - "id": 377, - "callFrame": { - "functionName": "decode", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 8, - "positionTicks": [ - { - "line": 136, - "ticks": 8 - } - ] - }, - { - "id": 391, - "callFrame": { - "functionName": "c", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 57887 - }, - "hitCount": 0, - "children": [ - 392 - ] - }, - { - "id": 392, - "callFrame": { - "functionName": "update", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 36579 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 2, - "ticks": 2 - } - ] - }, - { - "id": 731, - "callFrame": { - "functionName": "Ze", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 46226 - }, - "hitCount": 0, - "children": [ - 732 - ] - }, - { - "id": 732, - "callFrame": { - "functionName": "Writable.write", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 503, - "columnNumber": 35 - }, - "hitCount": 0, - "children": [ - 733 - ] - }, - { - "id": 733, - "callFrame": { - "functionName": "_write", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 452, - "columnNumber": 15 - }, - "hitCount": 0, - "children": [ - 734 - ] - }, - { - "id": 734, - "callFrame": { - "functionName": "writeOrBuffer", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 547, - "columnNumber": 22 - }, - "hitCount": 0, - "children": [ - 735 - ] - }, - { - "id": 735, - "callFrame": { - "functionName": "_write", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 17425 - }, - "hitCount": 0, - "children": [ - 736 - ] - }, - { - "id": 736, - "callFrame": { - "functionName": "startLoop", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 18058 - }, - "hitCount": 0, - "children": [ - 737 - ] - }, - { - "id": 737, - "callFrame": { - "functionName": "getData", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 21249 - }, - "hitCount": 0, - "children": [ - 738 - ] - }, - { - "id": 738, - "callFrame": { - "functionName": "dataMessage", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 22111 - }, - "hitCount": 0, - "children": [ - 739 - ] - }, - { - "id": 739, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 0, - "children": [ - 740 - ] - }, - { - "id": 740, - "callFrame": { - "functionName": "Bo", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 45256 - }, - "hitCount": 0, - "children": [ - 741 - ] - }, - { - "id": 741, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 0, - "children": [ - 742 - ] - }, - { - "id": 742, - "callFrame": { - "functionName": "s", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 30368 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3, - "ticks": 1 - } - ] - }, - { - "id": 311, - "callFrame": { - "functionName": "maybeReadMore", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 856, - "columnNumber": 22 - }, - "hitCount": 1, - "children": [ - 312 - ], - "positionTicks": [ - { - "line": 860, - "ticks": 1 - } - ] - }, - { - "id": 312, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 313, - 357 - ] - }, - { - "id": 313, - "callFrame": { - "functionName": "nextTick", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 112, - "columnNumber": 17 - }, - "hitCount": 14, - "positionTicks": [ - { - "line": 139, - "ticks": 1 - }, - { - "line": 137, - "ticks": 8 - }, - { - "line": 140, - "ticks": 1 - }, - { - "line": 138, - "ticks": 3 - }, - { - "line": 113, - "ticks": 1 - } - ] - }, - { - "id": 357, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 20, - "positionTicks": [ - { - "line": 2, - "ticks": 20 - } - ] - }, - { - "id": 645, - "callFrame": { - "functionName": "write", - "scriptId": "86", - "url": "node:string_decoder", - "lineNumber": 93, - "columnNumber": 46 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 104, - "ticks": 1 - } - ] - }, - { - "id": 500, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 1152 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 136, - "ticks": 2 - } - ] - }, - { - "id": 544, - "callFrame": { - "functionName": "_unrefTimer", - "scriptId": "94", - "url": "node:net", - "lineNumber": 519, - "columnNumber": 51 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 520, - "ticks": 1 - } - ] - }, - { - "id": 547, - "callFrame": { - "functionName": "Socket.read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 779, - "columnNumber": 32 - }, - "hitCount": 0, - "children": [ - 548 - ] - }, - { - "id": 548, - "callFrame": { - "functionName": "Readable.read", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 646, - "columnNumber": 34 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 674, - "ticks": 1 - } - ] - }, - { - "id": 549, - "callFrame": { - "functionName": "nextTick", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 112, - "columnNumber": 17 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 113, - "ticks": 1 - } - ] - }, - { - "id": 558, - "callFrame": { - "functionName": "get", - "scriptId": "102", - "url": "node:internal/streams/duplex", - "lineNumber": 160, - "columnNumber": 7 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 161, - "ticks": 1 - } - ] - }, - { - "id": 580, - "callFrame": { - "functionName": "get", - "scriptId": "94", - "url": "node:net", - "lineNumber": 703, - "columnNumber": 15 - }, - "hitCount": 4, - "positionTicks": [ - { - "line": 704, - "ticks": 4 - } - ] - }, - { - "id": 644, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 961, - "ticks": 2 - } - ] - }, - { - "id": 61, - "callFrame": { - "functionName": "(garbage collector)", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 5260 - }, - { - "id": 72, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 84228 - }, - "hitCount": 0, - "children": [ - 73, - 82 - ] - }, - { - "id": 73, - "callFrame": { - "functionName": "emit", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 64498 - }, - "hitCount": 0, - "children": [ - 74, - 77 - ] - }, - { - "id": 74, - "callFrame": { - "functionName": "Tn", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 64123 - }, - "hitCount": 0, - "children": [ - 75 - ] - }, - { - "id": 75, - "callFrame": { - "functionName": "Event", - "scriptId": "60", - "url": "node:internal/event_target", - "lineNumber": 113, - "columnNumber": 13 - }, - "hitCount": 0, - "children": [ - 76 - ] - }, - { - "id": 76, - "callFrame": { - "functionName": "now", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 77, - "callFrame": { - "functionName": "dispatchEvent", - "scriptId": "60", - "url": "node:internal/event_target", - "lineNumber": 749, - "columnNumber": 15 - }, - "hitCount": 0, - "children": [ - 78 - ] - }, - { - "id": 78, - "callFrame": { - "functionName": "", - "scriptId": "60", - "url": "node:internal/event_target", - "lineNumber": 766, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 79 - ] - }, - { - "id": 79, - "callFrame": { - "functionName": "n", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 64293 - }, - "hitCount": 0, - "children": [ - 80 - ] - }, - { - "id": 80, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 2, - "columnNumber": 44716 - }, - "hitCount": 1, - "children": [ - 81, - 534 - ], - "positionTicks": [ - { - "line": 3, - "ticks": 1 - } - ] - }, - { - "id": 81, - "callFrame": { - "functionName": "ri", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77996 - }, - "hitCount": 5, - "children": [ - 370 - ], - "positionTicks": [ - { - "line": 1, - "ticks": 5 - } - ] - }, - { - "id": 370, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 371 - ] - }, - { - "id": 371, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 372 - ] - }, - { - "id": 372, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 373 - ] - }, - { - "id": 373, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 374 - ] - }, - { - "id": 374, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77531 - }, - "hitCount": 0, - "children": [ - 375 - ] - }, - { - "id": 375, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 376 - ] - }, - { - "id": 376, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 1, - "children": [ - 769 - ], - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 769, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77531 - }, - "hitCount": 0, - "children": [ - 770 - ] - }, - { - "id": 770, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 534, - "callFrame": { - "functionName": "updateCommits", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 2, - "columnNumber": 45570 - }, - "hitCount": 0, - "children": [ - 535 - ] - }, - { - "id": 535, - "callFrame": { - "functionName": "t", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 1030 - }, - "hitCount": 0, - "children": [ - 536 - ] - }, - { - "id": 536, - "callFrame": { - "functionName": "t", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 1030 - }, - "hitCount": 0, - "children": [ - 537 - ] - }, - { - "id": 537, - "callFrame": { - "functionName": "t", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 1030 - }, - "hitCount": 1, - "children": [ - 574 - ], - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 574, - "callFrame": { - "functionName": "t", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 1030 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 1, - "ticks": 2 - } - ] - }, - { - "id": 82, - "callFrame": { - "functionName": "ri", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77996 - }, - "hitCount": 2, - "children": [ - 83 - ], - "positionTicks": [ - { - "line": 1, - "ticks": 2 - } - ] - }, - { - "id": 83, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 84 - ] - }, - { - "id": 84, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 85 - ] - }, - { - "id": 85, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 86 - ] - }, - { - "id": 86, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 87 - ] - }, - { - "id": 87, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77531 - }, - "hitCount": 0, - "children": [ - 88 - ] - }, - { - "id": 88, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 1, - "children": [ - 89 - ], - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 89, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 0, - "children": [ - 90 - ] - }, - { - "id": 90, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77531 - }, - "hitCount": 0, - "children": [ - 91 - ] - }, - { - "id": 91, - "callFrame": { - "functionName": "ei", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 77454 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 92, - "callFrame": { - "functionName": "", - "scriptId": "94", - "url": "node:net", - "lineNumber": 343, - "columnNumber": 23 - }, - "hitCount": 1, - "children": [ - 93 - ], - "positionTicks": [ - { - "line": 346, - "ticks": 1 - } - ] - }, - { - "id": 93, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 0, - "children": [ - 94, - 416 - ] - }, - { - "id": 94, - "callFrame": { - "functionName": "", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 454, - "columnNumber": 34 - }, - "hitCount": 0, - "children": [ - 95 - ] - }, - { - "id": 95, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 0, - "children": [ - 96 - ] - }, - { - "id": 96, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 956 - }, - "hitCount": 0, - "children": [ - 97 - ] - }, - { - "id": 97, - "callFrame": { - "functionName": "s", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 703 - }, - "hitCount": 0, - "children": [ - 98 - ] - }, - { - "id": 98, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 133, - "columnNumber": 107 - }, - "hitCount": 1, - "children": [ - 99 - ], - "positionTicks": [ - { - "line": 136, - "ticks": 1 - } - ] - }, - { - "id": 99, - "callFrame": { - "functionName": "c", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 19413 - }, - "hitCount": 0, - "children": [ - 100 - ] - }, - { - "id": 100, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 18906 - }, - "hitCount": 1, - "children": [ - 101 - ], - "positionTicks": [ - { - "line": 132, - "ticks": 1 - } - ] - }, - { - "id": 101, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 19185 - }, - "hitCount": 0, - "children": [ - 102 - ] - }, - { - "id": 102, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 18997 - }, - "hitCount": 0, - "children": [ - 103 - ] - }, - { - "id": 103, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 3483 - }, - "hitCount": 0, - "children": [ - 104, - 114 - ] - }, - { - "id": 104, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 8670 - }, - "hitCount": 0, - "children": [ - 105 - ] - }, - { - "id": 105, - "callFrame": { - "functionName": "c", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5822 - }, - "hitCount": 2, - "children": [ - 106, - 112 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - }, - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 106, - "callFrame": { - "functionName": "s", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12027 - }, - "hitCount": 0, - "children": [ - 107, - 399, - 560 - ] - }, - { - "id": 107, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12365 - }, - "hitCount": 1, - "children": [ - 108 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 108, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 109 - ] - }, - { - "id": 109, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 1, - "children": [ - 110, - 247, - 364 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 110, - "callFrame": { - "functionName": "serializeRequestArguments", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124548 - }, - "hitCount": 0, - "children": [ - 111 - ] - }, - { - "id": 111, - "callFrame": { - "functionName": "oE", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116912 - }, - "hitCount": 8, - "positionTicks": [ - { - "line": 29, - "ticks": 8 - } - ] - }, - { - "id": 247, - "callFrame": { - "functionName": "serializeRequest", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124944 - }, - "hitCount": 0, - "children": [ - 248 - ] - }, - { - "id": 248, - "callFrame": { - "functionName": "b", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 125054 - }, - "hitCount": 0, - "children": [ - 249, - 538 - ] - }, - { - "id": 249, - "callFrame": { - "functionName": "fromString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86344 - }, - "hitCount": 0, - "children": [ - 250 - ] - }, - { - "id": 250, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 251 - ] - }, - { - "id": 251, - "callFrame": { - "functionName": "fromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 479, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 252 - ] - }, - { - "id": 252, - "callFrame": { - "functionName": "fromStringFast", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 446, - "columnNumber": 23 - }, - "hitCount": 0, - "children": [ - 253 - ] - }, - { - "id": 253, - "callFrame": { - "functionName": "createFromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 473, - "columnNumber": 25 - }, - "hitCount": 0, - "children": [ - 254, - 709 - ] - }, - { - "id": 254, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 474, - "ticks": 2 - } - ] - }, - { - "id": 709, - "callFrame": { - "functionName": "allocUnsafeSlow", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 416, - "columnNumber": 49 - }, - "hitCount": 0, - "children": [ - 710 - ] - }, - { - "id": 710, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 711 - ] - }, - { - "id": 711, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 961, - "ticks": 1 - } - ] - }, - { - "id": 538, - "callFrame": { - "functionName": "alloc", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 121701 - }, - "hitCount": 0, - "children": [ - 539 - ] - }, - { - "id": 539, - "callFrame": { - "functionName": "alloc", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86148 - }, - "hitCount": 0, - "children": [ - 540 - ] - }, - { - "id": 540, - "callFrame": { - "functionName": "allocUnsafe", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 406, - "columnNumber": 41 - }, - "hitCount": 0, - "children": [ - 541 - ] - }, - { - "id": 541, - "callFrame": { - "functionName": "allocate", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 431, - "columnNumber": 17 - }, - "hitCount": 0, - "children": [ - 542 - ] - }, - { - "id": 542, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 543 - ] - }, - { - "id": 543, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 961, - "ticks": 1 - } - ] - }, - { - "id": 364, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 365 - ] - }, - { - "id": 365, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 366 - ] - }, - { - "id": 366, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 3, - "children": [ - 367 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 3 - } - ] - }, - { - "id": 367, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 4, - "positionTicks": [ - { - "line": 2, - "ticks": 4 - } - ] - }, - { - "id": 399, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12075 - }, - "hitCount": 0, - "children": [ - 400 - ] - }, - { - "id": 400, - "callFrame": { - "functionName": "file", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 57791 - }, - "hitCount": 2, - "children": [ - 401 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 401, - "callFrame": { - "functionName": "Pa", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 58904 - }, - "hitCount": 0, - "children": [ - 402 - ] - }, - { - "id": 402, - "callFrame": { - "functionName": "Jm", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56907 - }, - "hitCount": 0, - "children": [ - 403 - ] - }, - { - "id": 403, - "callFrame": { - "functionName": "VM", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56421 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 560, - "callFrame": { - "functionName": "debug", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 15868 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 32, - "ticks": 1 - } - ] - }, - { - "id": 112, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5864 - }, - "hitCount": 2, - "children": [ - 113 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 2 - } - ] - }, - { - "id": 113, - "callFrame": { - "functionName": "j", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 6345 - }, - "hitCount": 13, - "children": [ - 351 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 4 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 2 - }, - { - "line": 27, - "ticks": 1 - }, - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 351, - "callFrame": { - "functionName": "join", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 18363 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 114, - "callFrame": { - "functionName": "c", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5822 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 416, - "callFrame": { - "functionName": "onceWrapper", - "scriptId": "22", - "url": "node:events", - "lineNumber": 627, - "columnNumber": 20 - }, - "hitCount": 0, - "children": [ - 417 - ] - }, - { - "id": 417, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 28465 - }, - "hitCount": 0, - "children": [ - 418 - ] - }, - { - "id": 418, - "callFrame": { - "functionName": "concat", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 577, - "columnNumber": 31 - }, - "hitCount": 0, - "children": [ - 419 - ] - }, - { - "id": 419, - "callFrame": { - "functionName": "allocUnsafe", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 406, - "columnNumber": 41 - }, - "hitCount": 0, - "children": [ - 420 - ] - }, - { - "id": 420, - "callFrame": { - "functionName": "allocate", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 431, - "columnNumber": 17 - }, - "hitCount": 0, - "children": [ - 421 - ] - }, - { - "id": 421, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 422 - ] - }, - { - "id": 422, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 961, - "ticks": 1 - } - ] - }, - { - "id": 115, - "callFrame": { - "functionName": "processTimers", - "scriptId": "10", - "url": "node:internal/timers", - "lineNumber": 507, - "columnNumber": 24 - }, - "hitCount": 0, - "children": [ - 116 - ] - }, - { - "id": 116, - "callFrame": { - "functionName": "listOnTimeout", - "scriptId": "10", - "url": "node:internal/timers", - "lineNumber": 527, - "columnNumber": 24 - }, - "hitCount": 0, - "children": [ - 117, - 379, - 456 - ] - }, - { - "id": 117, - "callFrame": { - "functionName": "", - "scriptId": "577", - "url": "piiRemoved/bufferedQueue.js", - "lineNumber": 39, - "columnNumber": 38 - }, - "hitCount": 0, - "children": [ - 118 - ] - }, - { - "id": 118, - "callFrame": { - "functionName": "run", - "scriptId": "577", - "url": "piiRemoved/bufferedQueue.js", - "lineNumber": 45, - "columnNumber": 7 - }, - "hitCount": 0, - "children": [ - 119 - ] - }, - { - "id": 119, - "callFrame": { - "functionName": "", - "scriptId": "577", - "url": "piiRemoved/bufferedQueue.js", - "lineNumber": 3, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 120 - ] - }, - { - "id": 120, - "callFrame": { - "functionName": "", - "scriptId": "577", - "url": "piiRemoved/bufferedQueue.js", - "lineNumber": 46, - "columnNumber": 57 - }, - "hitCount": 0, - "children": [ - 121 - ] - }, - { - "id": 121, - "callFrame": { - "functionName": "processOnWatcherCreateEvent", - "scriptId": "576", - "url": "piiRemoved/repoManager.js", - "lineNumber": 399, - "columnNumber": 31 - }, - "hitCount": 0, - "children": [ - 122 - ] - }, - { - "id": 122, - "callFrame": { - "functionName": "", - "scriptId": "576", - "url": "piiRemoved/repoManager.js", - "lineNumber": 4, - "columnNumber": 45 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 9, - "ticks": 1 - } - ] - }, - { - "id": 379, - "callFrame": { - "functionName": "", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 169, - "columnNumber": 798 - }, - "hitCount": 0, - "children": [ - 380 - ] - }, - { - "id": 380, - "callFrame": { - "functionName": "_poll", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 169, - "columnNumber": 534 - }, - "hitCount": 0, - "children": [ - 381, - 744 - ] - }, - { - "id": 381, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 105051 - }, - "hitCount": 0, - "children": [ - 382 - ] - }, - { - "id": 382, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 1, - "children": [ - 383 - ], - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 383, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 0, - "children": [ - 384, - 505, - 515 - ] - }, - { - "id": 384, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 385 - ] - }, - { - "id": 385, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 386, - 779 - ] - }, - { - "id": 386, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 387 - ] - }, - { - "id": 387, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 388 - ] - }, - { - "id": 388, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 1, - "children": [ - 389 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 389, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 2, - "ticks": 3 - } - ] - }, - { - "id": 779, - "callFrame": { - "functionName": "serializeRequest", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124944 - }, - "hitCount": 0, - "children": [ - 780 - ] - }, - { - "id": 780, - "callFrame": { - "functionName": "b", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 125054 - }, - "hitCount": 0, - "children": [ - 781 - ] - }, - { - "id": 781, - "callFrame": { - "functionName": "fromString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86344 - }, - "hitCount": 0, - "children": [ - 782 - ] - }, - { - "id": 782, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 783 - ] - }, - { - "id": 783, - "callFrame": { - "functionName": "fromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 479, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 784 - ] - }, - { - "id": 784, - "callFrame": { - "functionName": "fromStringFast", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 446, - "columnNumber": 23 - }, - "hitCount": 0, - "children": [ - 785 - ] - }, - { - "id": 785, - "callFrame": { - "functionName": "write", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 634, - "columnNumber": 11 - }, - "hitCount": 0, - "children": [ - 786 - ] - }, - { - "id": 786, - "callFrame": { - "functionName": "utf8Write", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1060, - "columnNumber": 38 - }, - "hitCount": 0, - "children": [ - 787 - ] - }, - { - "id": 787, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1068, - "ticks": 1 - } - ] - }, - { - "id": 505, - "callFrame": { - "functionName": "now", - "scriptId": "134", - "url": "node:internal/perf/performance", - "lineNumber": 136, - "columnNumber": 5 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 537, - "ticks": 1 - } - ] - }, - { - "id": 515, - "callFrame": { - "functionName": "h", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 41255 - }, - "hitCount": 1, - "children": [ - 516 - ], - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 516, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 122, - "columnNumber": 26504 - }, - "hitCount": 1, - "children": [ - 517 - ], - "positionTicks": [ - { - "line": 123, - "ticks": 1 - } - ] - }, - { - "id": 517, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 0, - "children": [ - 518 - ] - }, - { - "id": 518, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 1, - "children": [ - 519, - 655 - ], - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 519, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 520 - ] - }, - { - "id": 520, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 521 - ] - }, - { - "id": 521, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 522 - ] - }, - { - "id": 522, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 523 - ] - }, - { - "id": 523, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 524 - ] - }, - { - "id": 524, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 2, - "ticks": 2 - } - ] - }, - { - "id": 655, - "callFrame": { - "functionName": "Na", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24549 - }, - "hitCount": 0, - "children": [ - 656 - ] - }, - { - "id": 656, - "callFrame": { - "functionName": "cv", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24589 - }, - "hitCount": 0, - "children": [ - 657 - ] - }, - { - "id": 657, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40738 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 744, - "callFrame": { - "functionName": "clearTimeout", - "scriptId": "34", - "url": "node:timers", - "lineNumber": 156, - "columnNumber": 21 - }, - "hitCount": 0, - "children": [ - 745 - ] - }, - { - "id": 745, - "callFrame": { - "functionName": "unenroll", - "scriptId": "34", - "url": "node:timers", - "lineNumber": 75, - "columnNumber": 17 - }, - "hitCount": 0, - "children": [ - 746 - ] - }, - { - "id": 746, - "callFrame": { - "functionName": "removeAt", - "scriptId": "18", - "url": "node:internal/priority_queue", - "lineNumber": 98, - "columnNumber": 10 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 68, - "ticks": 1 - } - ] - }, - { - "id": 456, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 99055 - }, - "hitCount": 0, - "children": [ - 457 - ] - }, - { - "id": 457, - "callFrame": { - "functionName": "eventuallyUpdateResourceStates", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 51996 - }, - "hitCount": 0, - "children": [ - 458, - 700 - ] - }, - { - "id": 458, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 52025 - }, - "hitCount": 0, - "children": [ - 459 - ] - }, - { - "id": 459, - "callFrame": { - "functionName": "_takeResourceStateSnapshot", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 46305 - }, - "hitCount": 0, - "children": [ - 460, - 675, - 696 - ] - }, - { - "id": 460, - "callFrame": { - "functionName": "y5", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 1618 - }, - "hitCount": 0, - "children": [ - 461 - ] - }, - { - "id": 461, - "callFrame": { - "functionName": "KD", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 42886 - }, - "hitCount": 0, - "children": [ - 462, - 681 - ] - }, - { - "id": 462, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 231150 - }, - "hitCount": 0, - "children": [ - 463 - ] - }, - { - "id": 463, - "callFrame": { - "functionName": "get command", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 550679 - }, - "hitCount": 0, - "children": [ - 464, - 677 - ] - }, - { - "id": 464, - "callFrame": { - "functionName": "resolveChangeCommand", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 557445 - }, - "hitCount": 0, - "children": [ - 465, - 682, - 694 - ] - }, - { - "id": 465, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 122133 - }, - "hitCount": 0, - "children": [ - 466 - ] - }, - { - "id": 466, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 1, - "children": [ - 467 - ], - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 467, - "callFrame": { - "functionName": "Rs", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24920 - }, - "hitCount": 2, - "children": [ - 680 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 680, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24975 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 682, - "callFrame": { - "functionName": "get leftUri", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 550463 - }, - "hitCount": 0, - "children": [ - 683 - ] - }, - { - "id": 683, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 231150 - }, - "hitCount": 0, - "children": [ - 684 - ] - }, - { - "id": 684, - "callFrame": { - "functionName": "get resources", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 550752 - }, - "hitCount": 0, - "children": [ - 685 - ] - }, - { - "id": 685, - "callFrame": { - "functionName": "getResources", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 558268 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 694, - "callFrame": { - "functionName": "getTitle", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 559594 - }, - "hitCount": 0, - "children": [ - 695 - ] - }, - { - "id": 695, - "callFrame": { - "functionName": "t", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 128230 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 201, - "ticks": 1 - } - ] - }, - { - "id": 677, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 0, - "children": [ - 678, - 686 - ] - }, - { - "id": 678, - "callFrame": { - "functionName": "Rs", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24920 - }, - "hitCount": 3, - "children": [ - 679 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 3 - } - ] - }, - { - "id": 679, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24975 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 686, - "callFrame": { - "functionName": "getValue", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 112, - "columnNumber": 14119 - }, - "hitCount": 0, - "children": [ - 687 - ] - }, - { - "id": 687, - "callFrame": { - "functionName": "w", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 112, - "columnNumber": 18031 - }, - "hitCount": 0, - "children": [ - 688 - ] - }, - { - "id": 688, - "callFrame": { - "functionName": "x", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 112, - "columnNumber": 18249 - }, - "hitCount": 0, - "children": [ - 689 - ] - }, - { - "id": 689, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 4794 - }, - "hitCount": 0, - "children": [ - 690 - ] - }, - { - "id": 690, - "callFrame": { - "functionName": "Jt.c", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 4513 - }, - "hitCount": 0, - "children": [ - 691 - ] - }, - { - "id": 691, - "callFrame": { - "functionName": "toString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 59048 - }, - "hitCount": 0, - "children": [ - 692 - ] - }, - { - "id": 692, - "callFrame": { - "functionName": "H1", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 60686 - }, - "hitCount": 0, - "children": [ - 693 - ] - }, - { - "id": 693, - "callFrame": { - "functionName": "ES", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 59645 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 681, - "callFrame": { - "functionName": "am", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 9232 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 132, - "ticks": 1 - } - ] - }, - { - "id": 675, - "callFrame": { - "functionName": "KD", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 42886 - }, - "hitCount": 0, - "children": [ - 676 - ] - }, - { - "id": 676, - "callFrame": { - "functionName": "am", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 9232 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 132, - "ticks": 1 - } - ] - }, - { - "id": 696, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 46359 - }, - "hitCount": 0, - "children": [ - 697 - ] - }, - { - "id": 697, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 46386 - }, - "hitCount": 0, - "children": [ - 698 - ] - }, - { - "id": 698, - "callFrame": { - "functionName": "s4", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 41080 - }, - "hitCount": 0, - "children": [ - 699 - ] - }, - { - "id": 699, - "callFrame": { - "functionName": "n", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 42, - "columnNumber": 28715 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 43, - "ticks": 1 - } - ] - }, - { - "id": 700, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 701 - ] - }, - { - "id": 701, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 702, - 704 - ] - }, - { - "id": 702, - "callFrame": { - "functionName": "serializeRequestArguments", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124548 - }, - "hitCount": 0, - "children": [ - 703 - ] - }, - { - "id": 703, - "callFrame": { - "functionName": "oE", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116912 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 704, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 705 - ] - }, - { - "id": 705, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 706 - ] - }, - { - "id": 706, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 707 - ] - }, - { - "id": 707, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 123, - "callFrame": { - "functionName": "MessagePortMain._internalPort.emit", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 2862 - }, - "hitCount": 1, - "children": [ - 124 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 124, - "callFrame": { - "functionName": "emit", - "scriptId": "22", - "url": "node:events", - "lineNumber": 465, - "columnNumber": 43 - }, - "hitCount": 4, - "children": [ - 125, - 759 - ], - "positionTicks": [ - { - "line": 513, - "ticks": 3 - }, - { - "line": 519, - "ticks": 1 - } - ] - }, - { - "id": 125, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 6902 - }, - "hitCount": 3, - "children": [ - 126, - 754 - ], - "positionTicks": [ - { - "line": 553, - "ticks": 2 - }, - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 126, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 9408 - }, - "hitCount": 0, - "children": [ - 127 - ] - }, - { - "id": 127, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 128 - ] - }, - { - "id": 128, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 129 - ] - }, - { - "id": 129, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8520 - }, - "hitCount": 0, - "children": [ - 130 - ] - }, - { - "id": 130, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 9408 - }, - "hitCount": 0, - "children": [ - 131 - ] - }, - { - "id": 131, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 132 - ] - }, - { - "id": 132, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 133, - 503 - ] - }, - { - "id": 133, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 117726 - }, - "hitCount": 0, - "children": [ - 134 - ] - }, - { - "id": 134, - "callFrame": { - "functionName": "L", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118730 - }, - "hitCount": 1, - "children": [ - 135, - 143, - 167, - 471, - 594 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 135, - "callFrame": { - "functionName": "deserializeReplyOKJSON", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 126862 - }, - "hitCount": 3898, - "children": [ - 136 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 3898 - } - ] - }, - { - "id": 136, - "callFrame": { - "functionName": "readLongString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 122637 - }, - "hitCount": 0, - "children": [ - 137 - ] - }, - { - "id": 137, - "callFrame": { - "functionName": "toString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86960 - }, - "hitCount": 0, - "children": [ - 138 - ] - }, - { - "id": 138, - "callFrame": { - "functionName": "toString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 834, - "columnNumber": 45 - }, - "hitCount": 936, - "positionTicks": [ - { - "line": 837, - "ticks": 936 - } - ] - }, - { - "id": 143, - "callFrame": { - "functionName": "M", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 119649 - }, - "hitCount": 1, - "children": [ - 144, - 176 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 144, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 145 - ] - }, - { - "id": 145, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 146 - ] - }, - { - "id": 146, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 147 - ] - }, - { - "id": 147, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 10, - "positionTicks": [ - { - "line": 2, - "ticks": 10 - } - ] - }, - { - "id": 176, - "callFrame": { - "functionName": "Q", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120703 - }, - "hitCount": 0, - "children": [ - 177 - ] - }, - { - "id": 177, - "callFrame": { - "functionName": "S", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120789 - }, - "hitCount": 0, - "children": [ - 178, - 408, - 468 - ] - }, - { - "id": 178, - "callFrame": { - "functionName": "$onFileEvent", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 123420 - }, - "hitCount": 1, - "children": [ - 179 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 179, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 180, - 528 - ] - }, - { - "id": 180, - "callFrame": { - "functionName": "D", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2397 - }, - "hitCount": 1, - "children": [ - 181 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 181, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 182, - 556 - ] - }, - { - "id": 182, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 121048 - }, - "hitCount": 2, - "children": [ - 183, - 190, - 214, - 234, - 292, - 778 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - }, - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 183, - "callFrame": { - "functionName": "getWorkspaceFolder", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 67918 - }, - "hitCount": 0, - "children": [ - 184 - ] - }, - { - "id": 184, - "callFrame": { - "functionName": "getWorkspaceFolder", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 65835 - }, - "hitCount": 0, - "children": [ - 185 - ] - }, - { - "id": 185, - "callFrame": { - "functionName": "findSubstr", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 40, - "columnNumber": 7104 - }, - "hitCount": 2, - "children": [ - 186 - ], - "positionTicks": [ - { - "line": 41, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 186, - "callFrame": { - "functionName": "reset", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 40, - "columnNumber": 2091 - }, - "hitCount": 0, - "children": [ - 187 - ] - }, - { - "id": 187, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 65315 - }, - "hitCount": 0, - "children": [ - 188 - ] - }, - { - "id": 188, - "callFrame": { - "functionName": "jb", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 64756 - }, - "hitCount": 0, - "children": [ - 189 - ] - }, - { - "id": 189, - "callFrame": { - "functionName": "getCapabilities", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 40, - "columnNumber": 10717 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 41, - "ticks": 1 - } - ] - }, - { - "id": 190, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 191 - ] - }, - { - "id": 191, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 1, - "children": [ - 192, - 198, - 228, - 238, - 296, - 552, - 585, - 760 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 192, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610351 - }, - "hitCount": 0, - "children": [ - 193 - ] - }, - { - "id": 193, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610195 - }, - "hitCount": 0, - "children": [ - 194 - ] - }, - { - "id": 194, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610351 - }, - "hitCount": 0, - "children": [ - 195, - 491 - ] - }, - { - "id": 195, - "callFrame": { - "functionName": "onFileChange", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 602939 - }, - "hitCount": 2, - "children": [ - 196, - 294 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - }, - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 196, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 122133 - }, - "hitCount": 0, - "children": [ - 197 - ] - }, - { - "id": 197, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 4, - "children": [ - 227 - ], - "positionTicks": [ - { - "line": 114, - "ticks": 4 - } - ] - }, - { - "id": 227, - "callFrame": { - "functionName": "Rs", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24920 - }, - "hitCount": 9, - "children": [ - 472 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 7 - } - ] - }, - { - "id": 472, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24975 - }, - "hitCount": 3, - "children": [ - 777 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 3 - } - ] - }, - { - "id": 777, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 5034 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 294, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3501 - }, - "hitCount": 0, - "children": [ - 295 - ] - }, - { - "id": 295, - "callFrame": { - "functionName": "h", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 5536 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 491, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 198, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 304, - "columnNumber": 12062 - }, - "hitCount": 1, - "children": [ - 199 - ], - "positionTicks": [ - { - "line": 222, - "ticks": 1 - } - ] - }, - { - "id": 199, - "callFrame": { - "functionName": "fire", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 1348 - }, - "hitCount": 1, - "children": [ - 200 - ], - "positionTicks": [ - { - "line": 228, - "ticks": 1 - } - ] - }, - { - "id": 200, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8258 - }, - "hitCount": 0, - "children": [ - 201 - ] - }, - { - "id": 201, - "callFrame": { - "functionName": "refresh", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 234, - "columnNumber": 875 - }, - "hitCount": 0, - "children": [ - 202 - ] - }, - { - "id": 202, - "callFrame": { - "functionName": "r", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 239, - "columnNumber": 935 - }, - "hitCount": 0, - "children": [ - 203 - ] - }, - { - "id": 203, - "callFrame": { - "functionName": "findFiles", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 119433 - }, - "hitCount": 0, - "children": [ - 204 - ] - }, - { - "id": 204, - "callFrame": { - "functionName": "findFiles", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 68930 - }, - "hitCount": 0, - "children": [ - 205 - ] - }, - { - "id": 205, - "callFrame": { - "functionName": "z", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 69464 - }, - "hitCount": 1, - "children": [ - 206 - ], - "positionTicks": [ - { - "line": 111, - "ticks": 1 - } - ] - }, - { - "id": 206, - "callFrame": { - "functionName": "A", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70619 - }, - "hitCount": 1, - "children": [ - 207 - ], - "positionTicks": [ - { - "line": 111, - "ticks": 1 - } - ] - }, - { - "id": 207, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70657 - }, - "hitCount": 0, - "children": [ - 208 - ] - }, - { - "id": 208, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 209, - 307 - ] - }, - { - "id": 209, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 210, - 239 - ] - }, - { - "id": 210, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 211 - ] - }, - { - "id": 211, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 212 - ] - }, - { - "id": 212, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 1, - "children": [ - 213 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 213, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 4, - "positionTicks": [ - { - "line": 2, - "ticks": 4 - } - ] - }, - { - "id": 239, - "callFrame": { - "functionName": "serializeRequest", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 124944 - }, - "hitCount": 0, - "children": [ - 240 - ] - }, - { - "id": 240, - "callFrame": { - "functionName": "b", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 125054 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 307, - "callFrame": { - "functionName": "add", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 24, - "columnNumber": 1521 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 25, - "ticks": 1 - } - ] - }, - { - "id": 228, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 304, - "columnNumber": 12116 - }, - "hitCount": 0, - "children": [ - 229, - 561 - ] - }, - { - "id": 229, - "callFrame": { - "functionName": "fire", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 1348 - }, - "hitCount": 9, - "children": [ - 506 - ], - "positionTicks": [ - { - "line": 228, - "ticks": 9 - } - ] - }, - { - "id": 506, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8186 - }, - "hitCount": 0, - "children": [ - 507 - ] - }, - { - "id": 507, - "callFrame": { - "functionName": "fetchAndSet", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 4450 - }, - "hitCount": 0, - "children": [ - 508 - ] - }, - { - "id": 508, - "callFrame": { - "functionName": "fetch", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 4337 - }, - "hitCount": 1, - "children": [ - 509 - ], - "positionTicks": [ - { - "line": 277, - "ticks": 1 - } - ] - }, - { - "id": 509, - "callFrame": { - "functionName": "supports", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 276, - "columnNumber": 11133 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 277, - "ticks": 1 - } - ] - }, - { - "id": 561, - "callFrame": { - "functionName": "re", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8649 - }, - "hitCount": 0, - "children": [ - 562 - ] - }, - { - "id": 562, - "callFrame": { - "functionName": "parse", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 21964 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 222, - "ticks": 1 - } - ] - }, - { - "id": 238, - "callFrame": { - "functionName": "", - "scriptId": "748", - "url": "piiRemoved/extension.js", - "lineNumber": 3001, - "columnNumber": 16211 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3002, - "ticks": 1 - } - ] - }, - { - "id": 296, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 304, - "columnNumber": 12170 - }, - "hitCount": 0, - "children": [ - 297 - ] - }, - { - "id": 297, - "callFrame": { - "functionName": "fire", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 1348 - }, - "hitCount": 1, - "children": [ - 298 - ], - "positionTicks": [ - { - "line": 228, - "ticks": 1 - } - ] - }, - { - "id": 298, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8348 - }, - "hitCount": 0, - "children": [ - 299 - ] - }, - { - "id": 299, - "callFrame": { - "functionName": "delete", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 2397 - }, - "hitCount": 0, - "children": [ - 300 - ] - }, - { - "id": 300, - "callFrame": { - "functionName": "getTrieIdentifier", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 3625 - }, - "hitCount": 0, - "children": [ - 301 - ] - }, - { - "id": 301, - "callFrame": { - "functionName": "yw", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 5328 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 228, - "ticks": 1 - } - ] - }, - { - "id": 552, - "callFrame": { - "functionName": "onWatcherCreate", - "scriptId": "576", - "url": "piiRemoved/repoManager.js", - "lineNumber": 374, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 553 - ] - }, - { - "id": 553, - "callFrame": { - "functionName": "enqueue", - "scriptId": "577", - "url": "piiRemoved/bufferedQueue.js", - "lineNumber": 29, - "columnNumber": 11 - }, - "hitCount": 1, - "children": [ - 763 - ], - "positionTicks": [ - { - "line": 33, - "ticks": 1 - } - ] - }, - { - "id": 763, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 764 - ] - }, - { - "id": 764, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 585, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 13341 - }, - "hitCount": 0, - "children": [ - 586 - ] - }, - { - "id": 586, - "callFrame": { - "functionName": "_triggerOnFileChange", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 14428 - }, - "hitCount": 0, - "children": [ - 587 - ] - }, - { - "id": 587, - "callFrame": { - "functionName": "getIgnoreGlobs", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 13895 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3844, - "ticks": 1 - } - ] - }, - { - "id": 760, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 13448 - }, - "hitCount": 0, - "children": [ - 761 - ] - }, - { - "id": 761, - "callFrame": { - "functionName": "_triggerOnFileChange", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 14428 - }, - "hitCount": 0, - "children": [ - 762 - ] - }, - { - "id": 762, - "callFrame": { - "functionName": "getIgnoreGlobs", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 13895 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3844, - "ticks": 1 - } - ] - }, - { - "id": 214, - "callFrame": { - "functionName": "", - "scriptId": "639", - "url": "piiRemoved/extension.js", - "lineNumber": 0, - "columnNumber": 1282 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1, - "ticks": 1 - } - ] - }, - { - "id": 234, - "callFrame": { - "functionName": "r", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10526 - }, - "hitCount": 0, - "children": [ - 235, - 236 - ] - }, - { - "id": 235, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10259 - }, - "hitCount": 10, - "positionTicks": [ - { - "line": 107, - "ticks": 10 - } - ] - }, - { - "id": 236, - "callFrame": { - "functionName": "i", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 8942 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - }, - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 292, - "callFrame": { - "functionName": "get created", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 122779 - }, - "hitCount": 0, - "children": [ - 293 - ] - }, - { - "id": 293, - "callFrame": { - "functionName": "get value", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 21599 - }, - "hitCount": 2, - "children": [ - 393 - ], - "positionTicks": [ - { - "line": 27, - "ticks": 2 - } - ] - }, - { - "id": 393, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 122908 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 142, - "ticks": 2 - } - ] - }, - { - "id": 778, - "callFrame": { - "functionName": "", - "scriptId": "748", - "url": "piiRemoved/extension.js", - "lineNumber": 3001, - "columnNumber": 16211 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3002, - "ticks": 1 - } - ] - }, - { - "id": 556, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10259 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 107, - "ticks": 1 - } - ] - }, - { - "id": 528, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 121048 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 408, - "callFrame": { - "functionName": "$provideFileSearchResults", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 11747 - }, - "hitCount": 1, - "children": [ - 658 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 658, - "callFrame": { - "functionName": "I", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12300 - }, - "hitCount": 0, - "children": [ - 659 - ] - }, - { - "id": 659, - "callFrame": { - "functionName": "doInternalFileSearchWithCustomCallback", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12011 - }, - "hitCount": 0, - "children": [ - 660 - ] - }, - { - "id": 660, - "callFrame": { - "functionName": "getNumThreadsCached", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 11203 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 468, - "callFrame": { - "functionName": "$provideDecorations", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 4365 - }, - "hitCount": 0, - "children": [ - 469 - ] - }, - { - "id": 469, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 4527 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 121, - "ticks": 1 - } - ] - }, - { - "id": 167, - "callFrame": { - "functionName": "O", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120293 - }, - "hitCount": 12, - "children": [ - 289 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 3 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 1 - }, - { - "line": 29, - "ticks": 3 - }, - { - "line": 29, - "ticks": 3 - } - ] - }, - { - "id": 289, - "callFrame": { - "functionName": "resolveOk", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 121582 - }, - "hitCount": 0, - "children": [ - 290, - 404 - ] - }, - { - "id": 290, - "callFrame": { - "functionName": "resolveOk", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116082 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 404, - "callFrame": { - "functionName": "dispose", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 24, - "columnNumber": 1376 - }, - "hitCount": 0, - "children": [ - 405 - ] - }, - { - "id": 405, - "callFrame": { - "functionName": "clear", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 24, - "columnNumber": 1457 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 25, - "ticks": 2 - } - ] - }, - { - "id": 471, - "callFrame": { - "functionName": "deserializeRequestJSONArgs", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 125319 - }, - "hitCount": 7, - "children": [ - 487 - ], - "positionTicks": [ - { - "line": 29, - "ticks": 7 - } - ] - }, - { - "id": 487, - "callFrame": { - "functionName": "readShortString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 122349 - }, - "hitCount": 0, - "children": [ - 488 - ] - }, - { - "id": 488, - "callFrame": { - "functionName": "slice", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 87051 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 594, - "callFrame": { - "functionName": "G", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118037 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 503, - "callFrame": { - "functionName": "L", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118730 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 754, - "callFrame": { - "functionName": "wrap", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86229 - }, - "hitCount": 0, - "children": [ - 755 - ] - }, - { - "id": 755, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 756 - ] - }, - { - "id": 756, - "callFrame": { - "functionName": "fromArrayBuffer", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 492, - "columnNumber": 24 - }, - "hitCount": 0, - "children": [ - 757 - ] - }, - { - "id": 757, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 961, - "ticks": 1 - } - ] - }, - { - "id": 759, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8520 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 393, - "ticks": 1 - } - ] - }, - { - "id": 139, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70717 - }, - "hitCount": 559, - "children": [ - 140 - ], - "positionTicks": [ - { - "line": 111, - "ticks": 559 - } - ] - }, - { - "id": 140, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70743 - }, - "hitCount": 212, - "children": [ - 141, - 173 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 2 - }, - { - "line": 111, - "ticks": 3 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 11 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 28, - "ticks": 7 - }, - { - "line": 28, - "ticks": 10 - }, - { - "line": 28, - "ticks": 15 - }, - { - "line": 28, - "ticks": 6 - }, - { - "line": 111, - "ticks": 14 - }, - { - "line": 28, - "ticks": 3 - }, - { - "line": 28, - "ticks": 4 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 11 - }, - { - "line": 28, - "ticks": 22 - }, - { - "line": 111, - "ticks": 17 - }, - { - "line": 28, - "ticks": 8 - }, - { - "line": 28, - "ticks": 15 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 12 - }, - { - "line": 28, - "ticks": 15 - } - ] - }, - { - "id": 141, - "callFrame": { - "functionName": "revive", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 58355 - }, - "hitCount": 27, - "children": [ - 168 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 12 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 9 - } - ] - }, - { - "id": 168, - "callFrame": { - "functionName": "Pa", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 58904 - }, - "hitCount": 0, - "children": [ - 169 - ] - }, - { - "id": 169, - "callFrame": { - "functionName": "Jm", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56907 - }, - "hitCount": 116, - "positionTicks": [ - { - "line": 28, - "ticks": 11 - }, - { - "line": 28, - "ticks": 17 - }, - { - "line": 28, - "ticks": 88 - } - ] - }, - { - "id": 173, - "callFrame": { - "functionName": "Pa", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 58904 - }, - "hitCount": 7, - "children": [ - 174 - ], - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 6 - } - ] - }, - { - "id": 174, - "callFrame": { - "functionName": "Jm", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 56907 - }, - "hitCount": 12, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 5 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 2 - }, - { - "line": 28, - "ticks": 1 - }, - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 142, - "callFrame": { - "functionName": "A", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70619 - }, - "hitCount": 115, - "positionTicks": [ - { - "line": 111, - "ticks": 115 - } - ] - }, - { - "id": 148, - "callFrame": { - "functionName": "doInternalFileSearchWithCustomCallback", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 12011 - }, - "hitCount": 0, - "children": [ - 149 - ] - }, - { - "id": 149, - "callFrame": { - "functionName": "doFileSearch", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5703 - }, - "hitCount": 0, - "children": [ - 150 - ] - }, - { - "id": 150, - "callFrame": { - "functionName": "doFileSearchWithEngine", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 5787 - }, - "hitCount": 1, - "children": [ - 151, - 481 - ], - "positionTicks": [ - { - "line": 142, - "ticks": 1 - } - ] - }, - { - "id": 151, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 8532 - }, - "hitCount": 0, - "children": [ - 152, - 489 - ] - }, - { - "id": 152, - "callFrame": { - "functionName": "search", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 3438 - }, - "hitCount": 0, - "children": [ - 153 - ] - }, - { - "id": 153, - "callFrame": { - "functionName": "walk", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 18657 - }, - "hitCount": 0, - "children": [ - 154 - ] - }, - { - "id": 154, - "callFrame": { - "functionName": "w", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 19058 - }, - "hitCount": 0, - "children": [ - 155 - ] - }, - { - "id": 155, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 18871 - }, - "hitCount": 0, - "children": [ - 156 - ] - }, - { - "id": 156, - "callFrame": { - "functionName": "x", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 19282 - }, - "hitCount": 0, - "children": [ - 157 - ] - }, - { - "id": 157, - "callFrame": { - "functionName": "y", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 19338 - }, - "hitCount": 1, - "children": [ - 158, - 771 - ], - "positionTicks": [ - { - "line": 132, - "ticks": 1 - } - ] - }, - { - "id": 158, - "callFrame": { - "functionName": "M_", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 16034 - }, - "hitCount": 0, - "children": [ - 159, - 409 - ] - }, - { - "id": 159, - "callFrame": { - "functionName": "spawn", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 810, - "columnNumber": 14 - }, - "hitCount": 3, - "children": [ - 160, - 161 - ], - "positionTicks": [ - { - "line": 812, - "ticks": 3 - } - ] - }, - { - "id": 160, - "callFrame": { - "functionName": "normalizeSpawnArguments", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 566, - "columnNumber": 32 - }, - "hitCount": 13, - "positionTicks": [ - { - "line": 641, - "ticks": 13 - } - ] - }, - { - "id": 161, - "callFrame": { - "functionName": "spawn", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 353, - "columnNumber": 45 - }, - "hitCount": 3, - "children": [ - 162, - 163, - 309 - ], - "positionTicks": [ - { - "line": 473, - "ticks": 1 - }, - { - "line": 395, - "ticks": 2 - } - ] - }, - { - "id": 162, - "callFrame": { - "functionName": "spawn", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 26, - "positionTicks": [ - { - "line": 395, - "ticks": 26 - } - ] - }, - { - "id": 163, - "callFrame": { - "functionName": "createSocket", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 333, - "columnNumber": 21 - }, - "hitCount": 0, - "children": [ - 164 - ] - }, - { - "id": 164, - "callFrame": { - "functionName": "Socket", - "scriptId": "94", - "url": "node:net", - "lineNumber": 361, - "columnNumber": 15 - }, - "hitCount": 0, - "children": [ - 165 - ] - }, - { - "id": 165, - "callFrame": { - "functionName": "Socket", - "scriptId": "94", - "url": "node:net", - "lineNumber": 361, - "columnNumber": 15 - }, - "hitCount": 2, - "children": [ - 166, - 413, - 490, - 555, - 749 - ], - "positionTicks": [ - { - "line": 408, - "ticks": 1 - }, - { - "line": 417, - "ticks": 1 - } - ] - }, - { - "id": 166, - "callFrame": { - "functionName": "initSocketHandle", - "scriptId": "94", - "url": "node:net", - "lineNumber": 317, - "columnNumber": 25 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 325, - "ticks": 1 - } - ] - }, - { - "id": 413, - "callFrame": { - "functionName": "Readable.on", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1126, - "columnNumber": 32 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1127, - "ticks": 1 - } - ] - }, - { - "id": 490, - "callFrame": { - "functionName": "Stream", - "scriptId": "103", - "url": "node:internal/streams/legacy", - "lineNumber": 10, - "columnNumber": 15 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 11, - "ticks": 1 - } - ] - }, - { - "id": 555, - "callFrame": { - "functionName": "set", - "scriptId": "94", - "url": "node:net", - "lineNumber": 2446, - "columnNumber": 5 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2447, - "ticks": 1 - } - ] - }, - { - "id": 749, - "callFrame": { - "functionName": "Socket.read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 779, - "columnNumber": 32 - }, - "hitCount": 0, - "children": [ - 750 - ] - }, - { - "id": 750, - "callFrame": { - "functionName": "Readable.read", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 646, - "columnNumber": 34 - }, - "hitCount": 0, - "children": [ - 751 - ] - }, - { - "id": 751, - "callFrame": { - "functionName": "Socket._read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 719, - "columnNumber": 33 - }, - "hitCount": 0, - "children": [ - 752 - ] - }, - { - "id": 752, - "callFrame": { - "functionName": "tryReadStart", - "scriptId": "94", - "url": "node:net", - "lineNumber": 709, - "columnNumber": 21 - }, - "hitCount": 0, - "children": [ - 753 - ] - }, - { - "id": 753, - "callFrame": { - "functionName": "readStart", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 714, - "ticks": 1 - } - ] - }, - { - "id": 309, - "callFrame": { - "functionName": "getValidStdio", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 983, - "columnNumber": 22 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 992, - "ticks": 1 - } - ] - }, - { - "id": 409, - "callFrame": { - "functionName": "L_", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 16198 - }, - "hitCount": 2, - "children": [ - 410 - ], - "positionTicks": [ - { - "line": 132, - "ticks": 2 - } - ] - }, - { - "id": 410, - "callFrame": { - "functionName": "JS", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 91989 - }, - "hitCount": 0, - "children": [ - 411 - ] - }, - { - "id": 411, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 9736 - }, - "hitCount": 0, - "children": [ - 412 - ] - }, - { - "id": 412, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 7, - "columnNumber": 6233 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 8, - "ticks": 1 - } - ] - }, - { - "id": 771, - "callFrame": { - "functionName": "z", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 687 - }, - "hitCount": 0, - "children": [ - 772 - ] - }, - { - "id": 772, - "callFrame": { - "functionName": "Readable.on", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1126, - "columnNumber": 32 - }, - "hitCount": 0, - "children": [ - 773 - ] - }, - { - "id": 773, - "callFrame": { - "functionName": "_addListener", - "scriptId": "22", - "url": "node:events", - "lineNumber": 546, - "columnNumber": 21 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 574, - "ticks": 1 - } - ] - }, - { - "id": 489, - "callFrame": { - "functionName": "get onCancellationRequested", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 5207 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 481, - "callFrame": { - "functionName": "U_", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 17858 - }, - "hitCount": 0, - "children": [ - 482 - ] - }, - { - "id": 482, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 131, - "columnNumber": 18294 - }, - "hitCount": 0, - "children": [ - 483 - ] - }, - { - "id": 483, - "callFrame": { - "functionName": "z_", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 3594 - }, - "hitCount": 0, - "children": [ - 484 - ] - }, - { - "id": 484, - "callFrame": { - "functionName": "d", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 3638 - }, - "hitCount": 0, - "children": [ - 485, - 576 - ] - }, - { - "id": 485, - "callFrame": { - "functionName": "Nr", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 106, - "columnNumber": 10419 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 107, - "ticks": 1 - } - ] - }, - { - "id": 576, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 135, - "columnNumber": 3689 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 136, - "ticks": 1 - } - ] - }, - { - "id": 170, - "callFrame": { - "functionName": "Bc", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 221, - "columnNumber": 20641 - }, - "hitCount": 21, - "positionTicks": [ - { - "line": 222, - "ticks": 21 - } - ] - }, - { - "id": 172, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 110, - "columnNumber": 70743 - }, - "hitCount": 26, - "positionTicks": [ - { - "line": 111, - "ticks": 1 - }, - { - "line": 111, - "ticks": 25 - } - ] - }, - { - "id": 175, - "callFrame": { - "functionName": "fetchAndSet", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 4450 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 228, - "ticks": 1 - } - ] - }, - { - "id": 215, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 119960 - }, - "hitCount": 0, - "children": [ - 216, - 230, - 352 - ] - }, - { - "id": 216, - "callFrame": { - "functionName": "alloc", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86148 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 230, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 231 - ] - }, - { - "id": 231, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 232 - ] - }, - { - "id": 232, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 4, - "children": [ - 233 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 4 - } - ] - }, - { - "id": 233, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 5, - "positionTicks": [ - { - "line": 2, - "ticks": 5 - } - ] - }, - { - "id": 352, - "callFrame": { - "functionName": "serializeReplyOK", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 126042 - }, - "hitCount": 0, - "children": [ - 353, - 492 - ] - }, - { - "id": 353, - "callFrame": { - "functionName": "hv", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116413 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 29, - "ticks": 2 - } - ] - }, - { - "id": 492, - "callFrame": { - "functionName": "f", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 126462 - }, - "hitCount": 0, - "children": [ - 493 - ] - }, - { - "id": 493, - "callFrame": { - "functionName": "fromString", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 86344 - }, - "hitCount": 0, - "children": [ - 494 - ] - }, - { - "id": 494, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 495 - ] - }, - { - "id": 495, - "callFrame": { - "functionName": "fromString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 479, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 496 - ] - }, - { - "id": 496, - "callFrame": { - "functionName": "fromStringFast", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 446, - "columnNumber": 23 - }, - "hitCount": 0, - "children": [ - 497 - ] - }, - { - "id": 497, - "callFrame": { - "functionName": "createPool", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 154, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 498 - ] - }, - { - "id": 498, - "callFrame": { - "functionName": "createUnsafeBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 1093, - "columnNumber": 27 - }, - "hitCount": 0, - "children": [ - 499 - ] - }, - { - "id": 499, - "callFrame": { - "functionName": "FastBuffer", - "scriptId": "25", - "url": "node:internal/buffer", - "lineNumber": 959, - "columnNumber": 13 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 961, - "ticks": 1 - } - ] - }, - { - "id": 217, - "callFrame": { - "functionName": "_triggerOnFileChange", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 14428 - }, - "hitCount": 1, - "children": [ - 218, - 221 - ], - "positionTicks": [ - { - "line": 3844, - "ticks": 1 - } - ] - }, - { - "id": 218, - "callFrame": { - "functionName": "match", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 966, - "columnNumber": 1682 - }, - "hitCount": 0, - "children": [ - 219, - 308 - ] - }, - { - "id": 219, - "callFrame": { - "functionName": "matchOne", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 17158 - }, - "hitCount": 2, - "children": [ - 220 - ], - "positionTicks": [ - { - "line": 966, - "ticks": 1 - }, - { - "line": 966, - "ticks": 1 - } - ] - }, - { - "id": 220, - "callFrame": { - "functionName": "matchOne", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 17158 - }, - "hitCount": 2, - "children": [ - 748 - ], - "positionTicks": [ - { - "line": 967, - "ticks": 2 - } - ] - }, - { - "id": 748, - "callFrame": { - "functionName": "RegExp: ^node_modules$", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1 - }, - { - "id": 308, - "callFrame": { - "functionName": "slashSplit", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 966, - "columnNumber": 1548 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 967, - "ticks": 2 - }, - { - "line": 967, - "ticks": 1 - } - ] - }, - { - "id": 221, - "callFrame": { - "functionName": "iT", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 12586 - }, - "hitCount": 1, - "children": [ - 222 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 222, - "callFrame": { - "functionName": "make", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 13393 - }, - "hitCount": 2, - "children": [ - 223, - 302, - 569 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 2 - } - ] - }, - { - "id": 223, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 13815 - }, - "hitCount": 0, - "children": [ - 224 - ] - }, - { - "id": 224, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 14100 - }, - "hitCount": 1, - "children": [ - 225 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 225, - "callFrame": { - "functionName": "parse", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 966, - "columnNumber": 331 - }, - "hitCount": 1, - "children": [ - 226, - 501, - 571 - ], - "positionTicks": [ - { - "line": 967, - "ticks": 1 - } - ] - }, - { - "id": 226, - "callFrame": { - "functionName": "toMMPattern", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 6863 - }, - "hitCount": 11, - "children": [ - 237, - 356, - 747 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 9 - }, - { - "line": 965, - "ticks": 2 - } - ] - }, - { - "id": 237, - "callFrame": { - "functionName": "toRegExpSource", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 7216 - }, - "hitCount": 7, - "children": [ - 304, - 765 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 7 - } - ] - }, - { - "id": 304, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 7333 - }, - "hitCount": 1, - "children": [ - 305 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 305, - "callFrame": { - "functionName": "#m", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 8688 - }, - "hitCount": 0, - "children": [ - 306, - 575 - ] - }, - { - "id": 306, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 3799 - }, - "hitCount": 6, - "positionTicks": [ - { - "line": 965, - "ticks": 6 - } - ] - }, - { - "id": 575, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 3438 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 765, - "callFrame": { - "functionName": "#m", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 8688 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 356, - "callFrame": { - "functionName": "isEnd", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 5507 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 747, - "callFrame": { - "functionName": "isStart", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 5308 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 501, - "callFrame": { - "functionName": "#A", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 5832 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 571, - "callFrame": { - "functionName": "fromGlob", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 6793 - }, - "hitCount": 1, - "children": [ - 572 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 572, - "callFrame": { - "functionName": "#A", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 5832 - }, - "hitCount": 0, - "children": [ - 573 - ] - }, - { - "id": 573, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 3639 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 302, - "callFrame": { - "functionName": "preprocess", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 14411 - }, - "hitCount": 0, - "children": [ - 303 - ] - }, - { - "id": 303, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 14906 - }, - "hitCount": 1, - "children": [ - 511 - ], - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 511, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 14921 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 569, - "callFrame": { - "functionName": "", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 13693 - }, - "hitCount": 0, - "children": [ - 570 - ] - }, - { - "id": 570, - "callFrame": { - "functionName": "slashSplit", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 966, - "columnNumber": 1548 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 967, - "ticks": 1 - } - ] - }, - { - "id": 246, - "callFrame": { - "functionName": "flushStdio", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 315, - "columnNumber": 19 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 316, - "ticks": 1 - } - ] - }, - { - "id": 255, - "callFrame": { - "functionName": "updateWhenIdleAndWait", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 603492 - }, - "hitCount": 0, - "children": [ - 256 - ] - }, - { - "id": 256, - "callFrame": { - "functionName": "o", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 231389 - }, - "hitCount": 0, - "children": [ - 257 - ] - }, - { - "id": 257, - "callFrame": { - "functionName": "status", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 574719 - }, - "hitCount": 0, - "children": [ - 258 - ] - }, - { - "id": 258, - "callFrame": { - "functionName": "run", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 595043 - }, - "hitCount": 0, - "children": [ - 259 - ] - }, - { - "id": 259, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 260 - ] - }, - { - "id": 260, - "callFrame": { - "functionName": "D", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2397 - }, - "hitCount": 0, - "children": [ - 261 - ] - }, - { - "id": 261, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 262 - ] - }, - { - "id": 262, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610351 - }, - "hitCount": 0, - "children": [ - 263, - 592 - ] - }, - { - "id": 263, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 178339 - }, - "hitCount": 0, - "children": [ - 264 - ] - }, - { - "id": 264, - "callFrame": { - "functionName": "f", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 178103 - }, - "hitCount": 0, - "children": [ - 265 - ] - }, - { - "id": 265, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 0, - "children": [ - 266 - ] - }, - { - "id": 266, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 0, - "children": [ - 267 - ] - }, - { - "id": 267, - "callFrame": { - "functionName": "h", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 41255 - }, - "hitCount": 0, - "children": [ - 268 - ] - }, - { - "id": 268, - "callFrame": { - "functionName": "i.registerCommand.description", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 39691 - }, - "hitCount": 0, - "children": [ - 269 - ] - }, - { - "id": 269, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 0, - "children": [ - 270 - ] - }, - { - "id": 270, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 0, - "children": [ - 271 - ] - }, - { - "id": 271, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 272 - ] - }, - { - "id": 272, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 273 - ] - }, - { - "id": 273, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 274 - ] - }, - { - "id": 274, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 275 - ] - }, - { - "id": 275, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 592, - "callFrame": { - "functionName": "onDidChangeOperations", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 127946 - }, - "hitCount": 0, - "children": [ - 593 - ] - }, - { - "id": 593, - "callFrame": { - "functionName": "set state", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 127023 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 276, - "callFrame": { - "functionName": "run", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 595043 - }, - "hitCount": 0, - "children": [ - 277, - 280, - 450 - ] - }, - { - "id": 277, - "callFrame": { - "functionName": "optimisticUpdateEnabled", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 605802 - }, - "hitCount": 0, - "children": [ - 278 - ] - }, - { - "id": 278, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 122133 - }, - "hitCount": 0, - "children": [ - 279 - ] - }, - { - "id": 279, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 280, - "callFrame": { - "functionName": "updateModelState", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 596129 - }, - "hitCount": 0, - "children": [ - 281 - ] - }, - { - "id": 281, - "callFrame": { - "functionName": "_updateModelState", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 596369 - }, - "hitCount": 0, - "children": [ - 282 - ] - }, - { - "id": 282, - "callFrame": { - "functionName": "getWorktrees", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 62627 - }, - "hitCount": 0, - "children": [ - 283 - ] - }, - { - "id": 283, - "callFrame": { - "functionName": "getWorktreesFS", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 62685 - }, - "hitCount": 0, - "children": [ - 284 - ] - }, - { - "id": 284, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 122133 - }, - "hitCount": 0, - "children": [ - 285 - ] - }, - { - "id": 285, - "callFrame": { - "functionName": "getConfiguration", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3183 - }, - "hitCount": 0, - "children": [ - 286 - ] - }, - { - "id": 286, - "callFrame": { - "functionName": "Rs", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24920 - }, - "hitCount": 0, - "children": [ - 287 - ] - }, - { - "id": 287, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 24975 - }, - "hitCount": 0, - "children": [ - 288 - ] - }, - { - "id": 288, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 5034 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 450, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 451 - ] - }, - { - "id": 451, - "callFrame": { - "functionName": "D", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2397 - }, - "hitCount": 0, - "children": [ - 452 - ] - }, - { - "id": 452, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 453 - ] - }, - { - "id": 453, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610195 - }, - "hitCount": 0, - "children": [ - 454 - ] - }, - { - "id": 454, - "callFrame": { - "functionName": "o", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 231389 - }, - "hitCount": 0, - "children": [ - 455 - ] - }, - { - "id": 455, - "callFrame": { - "functionName": "onDidRunWriteOperation", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 623406 - }, - "hitCount": 1, - "children": [ - 670 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 670, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 671 - ] - }, - { - "id": 671, - "callFrame": { - "functionName": "D", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2397 - }, - "hitCount": 0, - "children": [ - 672 - ] - }, - { - "id": 672, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 673 - ] - }, - { - "id": 673, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 48725 - }, - "hitCount": 0, - "children": [ - 674 - ] - }, - { - "id": 674, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 291, - "callFrame": { - "functionName": "re", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8649 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 228, - "ticks": 2 - } - ] - }, - { - "id": 314, - "callFrame": { - "functionName": "readFile", - "scriptId": "84", - "url": "node:internal/fs/promises", - "lineNumber": 1241, - "columnNumber": 23 - }, - "hitCount": 0, - "children": [ - 315 - ] - }, - { - "id": 315, - "callFrame": { - "functionName": "readFileHandle", - "scriptId": "84", - "url": "node:internal/fs/promises", - "lineNumber": 514, - "columnNumber": 29 - }, - "hitCount": 1, - "children": [ - 316 - ], - "positionTicks": [ - { - "line": 523, - "ticks": 1 - } - ] - }, - { - "id": 316, - "callFrame": { - "functionName": "fstat", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 523, - "ticks": 1 - } - ] - }, - { - "id": 317, - "callFrame": { - "functionName": "getInputTemplate", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 573867 - }, - "hitCount": 0, - "children": [ - 318 - ] - }, - { - "id": 318, - "callFrame": { - "functionName": "getCommitTemplate", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 66557 - }, - "hitCount": 0, - "children": [ - 319 - ] - }, - { - "id": 319, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 39865 - }, - "hitCount": 0, - "children": [ - 320 - ] - }, - { - "id": 320, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34010 - }, - "hitCount": 0, - "children": [ - 321 - ] - }, - { - "id": 321, - "callFrame": { - "functionName": "_exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34356 - }, - "hitCount": 0, - "children": [ - 322 - ] - }, - { - "id": 322, - "callFrame": { - "functionName": "spawn", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 35087 - }, - "hitCount": 0, - "children": [ - 323, - 324 - ] - }, - { - "id": 323, - "callFrame": { - "functionName": "t.assign", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610649 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 2, - "ticks": 2 - } - ] - }, - { - "id": 324, - "callFrame": { - "functionName": "spawn", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 810, - "columnNumber": 14 - }, - "hitCount": 0, - "children": [ - 325 - ] - }, - { - "id": 325, - "callFrame": { - "functionName": "spawn", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 353, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 326 - ] - }, - { - "id": 326, - "callFrame": { - "functionName": "spawn", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 395, - "ticks": 3 - } - ] - }, - { - "id": 327, - "callFrame": { - "functionName": "processTicksAndRejections", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 71, - "columnNumber": 34 - }, - "hitCount": 5, - "children": [ - 328, - 406, - 414, - 529, - 550, - 588, - 589, - 591 - ], - "positionTicks": [ - { - "line": 106, - "ticks": 1 - }, - { - "line": 72, - "ticks": 1 - }, - { - "line": 565, - "ticks": 1 - }, - { - "line": 57, - "ticks": 1 - }, - { - "line": 541, - "ticks": 1 - } - ] - }, - { - "id": 328, - "callFrame": { - "functionName": "finish", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 948, - "columnNumber": 15 - }, - "hitCount": 0, - "children": [ - 329 - ] - }, - { - "id": 329, - "callFrame": { - "functionName": "Writable.destroy", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 1113, - "columnNumber": 37 - }, - "hitCount": 0, - "children": [ - 330 - ] - }, - { - "id": 330, - "callFrame": { - "functionName": "destroy", - "scriptId": "101", - "url": "node:internal/streams/destroy", - "lineNumber": 48, - "columnNumber": 16 - }, - "hitCount": 0, - "children": [ - 331 - ] - }, - { - "id": 331, - "callFrame": { - "functionName": "Socket._destroy", - "scriptId": "94", - "url": "node:net", - "lineNumber": 807, - "columnNumber": 36 - }, - "hitCount": 0, - "children": [ - 332, - 583, - 766 - ] - }, - { - "id": 332, - "callFrame": { - "functionName": "close", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 4, - "positionTicks": [ - { - "line": 808, - "ticks": 4 - } - ] - }, - { - "id": 583, - "callFrame": { - "functionName": "getStderr", - "scriptId": "63", - "url": "node:internal/bootstrap/switches/is_main_thread", - "lineNumber": 172, - "columnNumber": 18 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 173, - "ticks": 1 - } - ] - }, - { - "id": 766, - "callFrame": { - "functionName": "onDestroy", - "scriptId": "101", - "url": "node:internal/streams/destroy", - "lineNumber": 92, - "columnNumber": 20 - }, - "hitCount": 0, - "children": [ - 767 - ] - }, - { - "id": 767, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 768 - ] - }, - { - "id": 768, - "callFrame": { - "functionName": "nextTick", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 112, - "columnNumber": 17 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 137, - "ticks": 1 - } - ] - }, - { - "id": 406, - "callFrame": { - "functionName": "maybeReadMore_", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 863, - "columnNumber": 23 - }, - "hitCount": 3, - "children": [ - 407 - ], - "positionTicks": [ - { - "line": 893, - "ticks": 3 - } - ] - }, - { - "id": 407, - "callFrame": { - "functionName": "Socket.read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 779, - "columnNumber": 32 - }, - "hitCount": 3, - "children": [ - 512 - ], - "positionTicks": [ - { - "line": 785, - "ticks": 3 - } - ] - }, - { - "id": 512, - "callFrame": { - "functionName": "Readable.read", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 646, - "columnNumber": 34 - }, - "hitCount": 6, - "children": [ - 513 - ], - "positionTicks": [ - { - "line": 785, - "ticks": 1 - }, - { - "line": 739, - "ticks": 1 - }, - { - "line": 670, - "ticks": 1 - }, - { - "line": 748, - "ticks": 1 - }, - { - "line": 729, - "ticks": 1 - }, - { - "line": 641, - "ticks": 1 - } - ] - }, - { - "id": 513, - "callFrame": { - "functionName": "Socket._read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 719, - "columnNumber": 33 - }, - "hitCount": 0, - "children": [ - 514 - ] - }, - { - "id": 514, - "callFrame": { - "functionName": "get", - "scriptId": "94", - "url": "node:net", - "lineNumber": 2445, - "columnNumber": 5 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 2446, - "ticks": 2 - } - ] - }, - { - "id": 414, - "callFrame": { - "functionName": "processPromiseRejections", - "scriptId": "31", - "url": "node:internal/process/promises", - "lineNumber": 438, - "columnNumber": 33 - }, - "hitCount": 5, - "children": [ - 415 - ], - "positionTicks": [ - { - "line": 439, - "ticks": 5 - } - ] - }, - { - "id": 415, - "callFrame": { - "functionName": "SafeMap", - "scriptId": "3", - "url": "node:internal/per_context/primordials", - "lineNumber": 408, - "columnNumber": 15 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 409, - "ticks": 3 - } - ] - }, - { - "id": 529, - "callFrame": { - "functionName": "endWritableNT", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1719, - "columnNumber": 22 - }, - "hitCount": 0, - "children": [ - 530, - 545 - ] - }, - { - "id": 530, - "callFrame": { - "functionName": "Writable.end", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 807, - "columnNumber": 33 - }, - "hitCount": 0, - "children": [ - 531 - ] - }, - { - "id": 531, - "callFrame": { - "functionName": "prefinish", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 905, - "columnNumber": 18 - }, - "hitCount": 1, - "children": [ - 532 - ], - "positionTicks": [ - { - "line": 916, - "ticks": 1 - } - ] - }, - { - "id": 532, - "callFrame": { - "functionName": "Socket._final", - "scriptId": "94", - "url": "node:net", - "lineNumber": 529, - "columnNumber": 34 - }, - "hitCount": 1, - "children": [ - 533 - ], - "positionTicks": [ - { - "line": 542, - "ticks": 1 - } - ] - }, - { - "id": 533, - "callFrame": { - "functionName": "shutdown", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 546, - "ticks": 3 - } - ] - }, - { - "id": 545, - "callFrame": { - "functionName": "prefinish", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 905, - "columnNumber": 18 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 906, - "ticks": 1 - } - ] - }, - { - "id": 550, - "callFrame": { - "functionName": "flushStdio", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 315, - "columnNumber": 19 - }, - "hitCount": 2, - "children": [ - 581 - ], - "positionTicks": [ - { - "line": 316, - "ticks": 2 - } - ] - }, - { - "id": 581, - "callFrame": { - "functionName": "get", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1414, - "columnNumber": 7 - }, - "hitCount": 0, - "children": [ - 582 - ] - }, - { - "id": 582, - "callFrame": { - "functionName": "get", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 131, - "columnNumber": 7 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 132, - "ticks": 1 - } - ] - }, - { - "id": 588, - "callFrame": { - "functionName": "Socket.read", - "scriptId": "94", - "url": "node:net", - "lineNumber": 779, - "columnNumber": 32 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 780, - "ticks": 1 - } - ] - }, - { - "id": 589, - "callFrame": { - "functionName": "runMicrotasks", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 2, - "children": [ - 646 - ], - "positionTicks": [ - { - "line": 105, - "ticks": 2 - } - ] - }, - { - "id": 646, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 2580 - }, - "hitCount": 0, - "children": [ - 647 - ] - }, - { - "id": 647, - "callFrame": { - "functionName": "appendLine", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 465 - }, - "hitCount": 0, - "children": [ - 648 - ] - }, - { - "id": 648, - "callFrame": { - "functionName": "info", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 15354 - }, - "hitCount": 0, - "children": [ - 649 - ] - }, - { - "id": 649, - "callFrame": { - "functionName": "m", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 312 - }, - "hitCount": 0, - "children": [ - 650 - ] - }, - { - "id": 650, - "callFrame": { - "functionName": "sO", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 14445 - }, - "hitCount": 0, - "children": [ - 651 - ] - }, - { - "id": 651, - "callFrame": { - "functionName": "info", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 15354 - }, - "hitCount": 0, - "children": [ - 652 - ] - }, - { - "id": 652, - "callFrame": { - "functionName": "m", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 249, - "columnNumber": 9016 - }, - "hitCount": 0, - "children": [ - 653 - ] - }, - { - "id": 653, - "callFrame": { - "functionName": "JP", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 249, - "columnNumber": 8127 - }, - "hitCount": 0, - "children": [ - 654 - ] - }, - { - "id": 654, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 250, - "ticks": 1 - } - ] - }, - { - "id": 591, - "callFrame": { - "functionName": "SafeMap", - "scriptId": "3", - "url": "node:internal/per_context/primordials", - "lineNumber": 408, - "columnNumber": 15 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 409, - "ticks": 1 - } - ] - }, - { - "id": 334, - "callFrame": { - "functionName": "getRemotesFS", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 63812 - }, - "hitCount": 0, - "children": [ - 335 - ] - }, - { - "id": 335, - "callFrame": { - "functionName": "O", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 37253 - }, - "hitCount": 0, - "children": [ - 336 - ] - }, - { - "id": 336, - "callFrame": { - "functionName": "parse", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 36098 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 337, - "callFrame": { - "functionName": "getHEADRef", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 58588 - }, - "hitCount": 0, - "children": [ - 338 - ] - }, - { - "id": 338, - "callFrame": { - "functionName": "getRefs", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 60309 - }, - "hitCount": 0, - "children": [ - 339 - ] - }, - { - "id": 339, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 39865 - }, - "hitCount": 0, - "children": [ - 340 - ] - }, - { - "id": 340, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34010 - }, - "hitCount": 0, - "children": [ - 341 - ] - }, - { - "id": 341, - "callFrame": { - "functionName": "_exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34356 - }, - "hitCount": 0, - "children": [ - 342 - ] - }, - { - "id": 342, - "callFrame": { - "functionName": "spawn", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 35087 - }, - "hitCount": 0, - "children": [ - 343 - ] - }, - { - "id": 343, - "callFrame": { - "functionName": "spawn", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 810, - "columnNumber": 14 - }, - "hitCount": 1, - "children": [ - 344 - ], - "positionTicks": [ - { - "line": 812, - "ticks": 1 - } - ] - }, - { - "id": 344, - "callFrame": { - "functionName": "spawn", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 353, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 345 - ] - }, - { - "id": 345, - "callFrame": { - "functionName": "spawn", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 395, - "ticks": 2 - } - ] - }, - { - "id": 346, - "callFrame": { - "functionName": "resume_", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 1253, - "columnNumber": 16 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 1254, - "ticks": 1 - } - ] - }, - { - "id": 347, - "callFrame": { - "functionName": "ChildProcess._handle.onexit", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 268, - "columnNumber": 24 - }, - "hitCount": 0, - "children": [ - 348 - ] - }, - { - "id": 348, - "callFrame": { - "functionName": "Writable.destroy", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 1113, - "columnNumber": 37 - }, - "hitCount": 0, - "children": [ - 349 - ] - }, - { - "id": 349, - "callFrame": { - "functionName": "destroy", - "scriptId": "101", - "url": "node:internal/streams/destroy", - "lineNumber": 48, - "columnNumber": 16 - }, - "hitCount": 1, - "children": [ - 350 - ], - "positionTicks": [ - { - "line": 49, - "ticks": 1 - } - ] - }, - { - "id": 350, - "callFrame": { - "functionName": "Socket._destroy", - "scriptId": "94", - "url": "node:net", - "lineNumber": 807, - "columnNumber": 36 - }, - "hitCount": 1, - "children": [ - 378, - 554 - ], - "positionTicks": [ - { - "line": 808, - "ticks": 1 - } - ] - }, - { - "id": 378, - "callFrame": { - "functionName": "close", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 808, - "ticks": 3 - } - ] - }, - { - "id": 554, - "callFrame": { - "functionName": "getStderr", - "scriptId": "63", - "url": "node:internal/bootstrap/switches/is_main_thread", - "lineNumber": 172, - "columnNumber": 18 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 173, - "ticks": 2 - } - ] - }, - { - "id": 354, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 234, - "columnNumber": 918 - }, - "hitCount": 11, - "positionTicks": [ - { - "line": 235, - "ticks": 11 - } - ] - }, - { - "id": 355, - "callFrame": { - "functionName": "", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 227, - "columnNumber": 8258 - }, - "hitCount": 4, - "children": [ - 568 - ], - "positionTicks": [ - { - "line": 228, - "ticks": 2 - }, - { - "line": 228, - "ticks": 2 - } - ] - }, - { - "id": 568, - "callFrame": { - "functionName": "isMatch", - "scriptId": "420", - "url": "piiRemoved/extension-node.js", - "lineNumber": 234, - "columnNumber": 823 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 235, - "ticks": 2 - } - ] - }, - { - "id": 394, - "callFrame": { - "functionName": "getStatus", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 597655 - }, - "hitCount": 1, - "children": [ - 395 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 395, - "callFrame": { - "functionName": "get validateInput", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 44285 - }, - "hitCount": 0, - "children": [ - 396 - ] - }, - { - "id": 396, - "callFrame": { - "functionName": "T", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 107, - "columnNumber": 33239 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 108, - "ticks": 1 - } - ] - }, - { - "id": 397, - "callFrame": { - "functionName": "file", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 57791 - }, - "hitCount": 3, - "positionTicks": [ - { - "line": 28, - "ticks": 3 - } - ] - }, - { - "id": 398, - "callFrame": { - "functionName": "afterShutdown", - "scriptId": "94", - "url": "node:net", - "lineNumber": 553, - "columnNumber": 22 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 559, - "ticks": 1 - } - ] - }, - { - "id": 423, - "callFrame": { - "functionName": "_exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34356 - }, - "hitCount": 0, - "children": [ - 424, - 596, - 597 - ] - }, - { - "id": 424, - "callFrame": { - "functionName": "toString", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 834, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 425 - ] - }, - { - "id": 425, - "callFrame": { - "functionName": "slice", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 635, - "columnNumber": 11 - }, - "hitCount": 6, - "children": [ - 608 - ], - "positionTicks": [ - { - "line": 636, - "ticks": 6 - } - ] - }, - { - "id": 608, - "callFrame": { - "functionName": "utf8Slice", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 636, - "ticks": 1 - } - ] - }, - { - "id": 596, - "callFrame": { - "functionName": "P", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 29411 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 597, - "callFrame": { - "functionName": "D", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 28956 - }, - "hitCount": 0, - "children": [ - 598 - ] - }, - { - "id": 598, - "callFrame": { - "functionName": "D", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 28884 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 426, - "callFrame": { - "functionName": "getRefs", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 60309 - }, - "hitCount": 2, - "children": [ - 427 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 2 - } - ] - }, - { - "id": 427, - "callFrame": { - "functionName": "exec.cancellationToken", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 60849 - }, - "hitCount": 7, - "positionTicks": [ - { - "line": 2, - "ticks": 4 - }, - { - "line": 2, - "ticks": 1 - }, - { - "line": 2, - "ticks": 1 - }, - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 428, - "callFrame": { - "functionName": "_updateModelState", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 596369 - }, - "hitCount": 1, - "children": [ - 429, - 609, - 622 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 429, - "callFrame": { - "functionName": "fire", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2476 - }, - "hitCount": 0, - "children": [ - 430 - ] - }, - { - "id": 430, - "callFrame": { - "functionName": "D", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2397 - }, - "hitCount": 0, - "children": [ - 431 - ] - }, - { - "id": 431, - "callFrame": { - "functionName": "C", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2286 - }, - "hitCount": 0, - "children": [ - 432, - 447, - 661 - ] - }, - { - "id": 432, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 177998 - }, - "hitCount": 0, - "children": [ - 433 - ] - }, - { - "id": 433, - "callFrame": { - "functionName": "onDidChangeActiveTextEditor", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 170949 - }, - "hitCount": 0, - "children": [ - 434 - ] - }, - { - "id": 434, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 105051 - }, - "hitCount": 0, - "children": [ - 435 - ] - }, - { - "id": 435, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 0, - "children": [ - 436 - ] - }, - { - "id": 436, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 0, - "children": [ - 437 - ] - }, - { - "id": 437, - "callFrame": { - "functionName": "h", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 41255 - }, - "hitCount": 0, - "children": [ - 438 - ] - }, - { - "id": 438, - "callFrame": { - "functionName": "i.registerCommand.description", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 39691 - }, - "hitCount": 0, - "children": [ - 439 - ] - }, - { - "id": 439, - "callFrame": { - "functionName": "executeCommand", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40534 - }, - "hitCount": 0, - "children": [ - 440 - ] - }, - { - "id": 440, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 0, - "children": [ - 441 - ] - }, - { - "id": 441, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 442 - ] - }, - { - "id": 442, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 443 - ] - }, - { - "id": 443, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 444 - ] - }, - { - "id": 444, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 445 - ] - }, - { - "id": 445, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 446 - ] - }, - { - "id": 446, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 447, - "callFrame": { - "functionName": "", - "scriptId": "752", - "url": "piiRemoved/extension.js", - "lineNumber": 3144, - "columnNumber": 15453 - }, - "hitCount": 0, - "children": [ - 448 - ] - }, - { - "id": 448, - "callFrame": { - "functionName": "e", - "scriptId": "752", - "url": "piiRemoved/extension.js", - "lineNumber": 3144, - "columnNumber": 14859 - }, - "hitCount": 0, - "children": [ - 449 - ] - }, - { - "id": 449, - "callFrame": { - "functionName": "getOrCreateSingleRepoState", - "scriptId": "752", - "url": "piiRemoved/extension.js", - "lineNumber": 3144, - "columnNumber": 14073 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3145, - "ticks": 1 - } - ] - }, - { - "id": 661, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 567969 - }, - "hitCount": 0, - "children": [ - 662 - ] - }, - { - "id": 662, - "callFrame": { - "functionName": "updateInputBoxPlaceholder", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 605118 - }, - "hitCount": 0, - "children": [ - 663 - ] - }, - { - "id": 663, - "callFrame": { - "functionName": "set placeholder", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 200, - "columnNumber": 44213 - }, - "hitCount": 0, - "children": [ - 664 - ] - }, - { - "id": 664, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 665 - ] - }, - { - "id": 665, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 666 - ] - }, - { - "id": 666, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 667 - ] - }, - { - "id": 667, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 668 - ] - }, - { - "id": 668, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 669 - ] - }, - { - "id": 669, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 609, - "callFrame": { - "functionName": "getStatus", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 597655 - }, - "hitCount": 0, - "children": [ - 610, - 612 - ] - }, - { - "id": 610, - "callFrame": { - "functionName": "get", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 3501 - }, - "hitCount": 0, - "children": [ - 611 - ] - }, - { - "id": 611, - "callFrame": { - "functionName": "Eg", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 1739 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 612, - "callFrame": { - "functionName": "getStatus", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 57160 - }, - "hitCount": 0, - "children": [ - 613 - ] - }, - { - "id": 613, - "callFrame": { - "functionName": "stream", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 39932 - }, - "hitCount": 1, - "children": [ - 614 - ], - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 614, - "callFrame": { - "functionName": "stream", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34135 - }, - "hitCount": 0, - "children": [ - 615 - ] - }, - { - "id": 615, - "callFrame": { - "functionName": "spawn", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 35087 - }, - "hitCount": 0, - "children": [ - 616, - 617 - ] - }, - { - "id": 616, - "callFrame": { - "functionName": "t.assign", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 610649 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 617, - "callFrame": { - "functionName": "spawn", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 810, - "columnNumber": 14 - }, - "hitCount": 0, - "children": [ - 618 - ] - }, - { - "id": 618, - "callFrame": { - "functionName": "spawn", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 353, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 619, - 620 - ] - }, - { - "id": 619, - "callFrame": { - "functionName": "spawn", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 395, - "ticks": 2 - } - ] - }, - { - "id": 620, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 621 - ] - }, - { - "id": 621, - "callFrame": { - "functionName": "nextTick", - "scriptId": "30", - "url": "node:internal/process/task_queues", - "lineNumber": 112, - "columnNumber": 17 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 137, - "ticks": 1 - }, - { - "line": 113, - "ticks": 1 - } - ] - }, - { - "id": 622, - "callFrame": { - "functionName": "getRefs", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 584792 - }, - "hitCount": 0, - "children": [ - 623 - ] - }, - { - "id": 623, - "callFrame": { - "functionName": "run", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 595043 - }, - "hitCount": 0, - "children": [ - 624 - ] - }, - { - "id": 624, - "callFrame": { - "functionName": "retryRun", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 595563 - }, - "hitCount": 0, - "children": [ - 625 - ] - }, - { - "id": 625, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 584996 - }, - "hitCount": 0, - "children": [ - 626 - ] - }, - { - "id": 626, - "callFrame": { - "functionName": "getRefs", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 60309 - }, - "hitCount": 0, - "children": [ - 627 - ] - }, - { - "id": 627, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 39865 - }, - "hitCount": 0, - "children": [ - 628 - ] - }, - { - "id": 628, - "callFrame": { - "functionName": "exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34010 - }, - "hitCount": 0, - "children": [ - 629 - ] - }, - { - "id": 629, - "callFrame": { - "functionName": "_exec", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 34356 - }, - "hitCount": 0, - "children": [ - 630, - 634 - ] - }, - { - "id": 630, - "callFrame": { - "functionName": "spawn", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 35087 - }, - "hitCount": 0, - "children": [ - 631 - ] - }, - { - "id": 631, - "callFrame": { - "functionName": "spawn", - "scriptId": "92", - "url": "node:child_process", - "lineNumber": 810, - "columnNumber": 14 - }, - "hitCount": 0, - "children": [ - 632 - ] - }, - { - "id": 632, - "callFrame": { - "functionName": "spawn", - "scriptId": "93", - "url": "node:internal/child_process", - "lineNumber": 353, - "columnNumber": 45 - }, - "hitCount": 0, - "children": [ - 633 - ] - }, - { - "id": 633, - "callFrame": { - "functionName": "spawn", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 395, - "ticks": 1 - } - ] - }, - { - "id": 634, - "callFrame": { - "functionName": "E", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 27981 - }, - "hitCount": 0, - "children": [ - 635 - ] - }, - { - "id": 635, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 28642 - }, - "hitCount": 0, - "children": [ - 636, - 638 - ] - }, - { - "id": 636, - "callFrame": { - "functionName": "get onCancellationRequested", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 5207 - }, - "hitCount": 0, - "children": [ - 637 - ] - }, - { - "id": 637, - "callFrame": { - "functionName": "get event", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 829 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 638, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 615763 - }, - "hitCount": 0, - "children": [ - 639 - ] - }, - { - "id": 639, - "callFrame": { - "functionName": "u", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 848 - }, - "hitCount": 0, - "children": [ - 640 - ] - }, - { - "id": 640, - "callFrame": { - "functionName": "N2", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 26, - "columnNumber": 2732 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 27, - "ticks": 1 - } - ] - }, - { - "id": 470, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 4527 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 121, - "ticks": 1 - } - ] - }, - { - "id": 473, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 115, - "columnNumber": 11211 - }, - "hitCount": 0, - "children": [ - 474 - ] - }, - { - "id": 474, - "callFrame": { - "functionName": "n", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 115, - "columnNumber": 11064 - }, - "hitCount": 0, - "children": [ - 475 - ] - }, - { - "id": 475, - "callFrame": { - "functionName": "s..n.charCodeAt.s.", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 118481 - }, - "hitCount": 0, - "children": [ - 476 - ] - }, - { - "id": 476, - "callFrame": { - "functionName": "U", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 120975 - }, - "hitCount": 0, - "children": [ - 477 - ] - }, - { - "id": 477, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 8629 - }, - "hitCount": 0, - "children": [ - 478 - ] - }, - { - "id": 478, - "callFrame": { - "functionName": "send", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 392, - "columnNumber": 7023 - }, - "hitCount": 0, - "children": [ - 479 - ] - }, - { - "id": 479, - "callFrame": { - "functionName": "postMessage", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 3054 - }, - "hitCount": 0, - "children": [ - 480 - ] - }, - { - "id": 480, - "callFrame": { - "functionName": "postMessage", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 2, - "ticks": 1 - } - ] - }, - { - "id": 504, - "callFrame": { - "functionName": "_unrefTimer", - "scriptId": "94", - "url": "node:net", - "lineNumber": 519, - "columnNumber": 51 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 520, - "ticks": 1 - } - ] - }, - { - "id": 510, - "callFrame": { - "functionName": "iT", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 12586 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 965, - "ticks": 1 - }, - { - "line": 965, - "ticks": 1 - } - ] - }, - { - "id": 546, - "callFrame": { - "functionName": "readableAddChunkPushByteMode", - "scriptId": "104", - "url": "node:internal/streams/readable", - "lineNumber": 462, - "columnNumber": 37 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 464, - "ticks": 1 - } - ] - }, - { - "id": 557, - "callFrame": { - "functionName": "getIgnoreGlobs", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 3843, - "columnNumber": 13895 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 3844, - "ticks": 1 - } - ] - }, - { - "id": 563, - "callFrame": { - "functionName": "matchOne", - "scriptId": "743", - "url": "piiRemoved/extension.js", - "lineNumber": 964, - "columnNumber": 17158 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 967, - "ticks": 1 - } - ] - }, - { - "id": 564, - "callFrame": { - "functionName": "_poll", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 169, - "columnNumber": 534 - }, - "hitCount": 1, - "children": [ - 565 - ], - "positionTicks": [ - { - "line": 170, - "ticks": 1 - } - ] - }, - { - "id": 565, - "callFrame": { - "functionName": "", - "scriptId": "119", - "url": "node:electron/js2c/utility_init", - "lineNumber": 1, - "columnNumber": 14967 - }, - "hitCount": 0, - "children": [ - 566 - ] - }, - { - "id": 566, - "callFrame": { - "functionName": "setTimeout", - "scriptId": "34", - "url": "node:timers", - "lineNumber": 135, - "columnNumber": 19 - }, - "hitCount": 0, - "children": [ - 567 - ] - }, - { - "id": 567, - "callFrame": { - "functionName": "insert", - "scriptId": "10", - "url": "node:internal/timers", - "lineNumber": 367, - "columnNumber": 15 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 374, - "ticks": 1 - } - ] - }, - { - "id": 579, - "callFrame": { - "functionName": "j", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 141, - "columnNumber": 6345 - }, - "hitCount": 2, - "positionTicks": [ - { - "line": 142, - "ticks": 2 - } - ] - }, - { - "id": 590, - "callFrame": { - "functionName": "toJSON", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 27, - "columnNumber": 59147 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 28, - "ticks": 1 - } - ] - }, - { - "id": 595, - "callFrame": { - "functionName": "g", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 113, - "columnNumber": 40621 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 114, - "ticks": 1 - } - ] - }, - { - "id": 599, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 2580 - }, - "hitCount": 0, - "children": [ - 600 - ] - }, - { - "id": 600, - "callFrame": { - "functionName": "appendLine", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 465 - }, - "hitCount": 0, - "children": [ - 601 - ] - }, - { - "id": 601, - "callFrame": { - "functionName": "info", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 15354 - }, - "hitCount": 0, - "children": [ - 602 - ] - }, - { - "id": 602, - "callFrame": { - "functionName": "m", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 120, - "columnNumber": 312 - }, - "hitCount": 0, - "children": [ - 603 - ] - }, - { - "id": 603, - "callFrame": { - "functionName": "sO", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 14445 - }, - "hitCount": 0, - "children": [ - 604 - ] - }, - { - "id": 604, - "callFrame": { - "functionName": "info", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 31, - "columnNumber": 15354 - }, - "hitCount": 0, - "children": [ - 605 - ] - }, - { - "id": 605, - "callFrame": { - "functionName": "m", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 249, - "columnNumber": 9016 - }, - "hitCount": 0, - "children": [ - 606 - ] - }, - { - "id": 606, - "callFrame": { - "functionName": "JP", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 249, - "columnNumber": 8127 - }, - "hitCount": 0, - "children": [ - 607 - ] - }, - { - "id": 607, - "callFrame": { - "functionName": "", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 250, - "ticks": 1 - } - ] - }, - { - "id": 641, - "callFrame": { - "functionName": "then", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 116219 - }, - "hitCount": 0, - "children": [ - 642 - ] - }, - { - "id": 642, - "callFrame": { - "functionName": "j", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 115953 - }, - "hitCount": 0, - "children": [ - 643 - ] - }, - { - "id": 643, - "callFrame": { - "functionName": "", - "scriptId": "147", - "url": "piiRemoved/extensionHostProcess.js", - "lineNumber": 28, - "columnNumber": 115991 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 29, - "ticks": 1 - } - ] - }, - { - "id": 708, - "callFrame": { - "functionName": "", - "scriptId": "806", - "url": "piiRemoved/extension-CXz73ARr.js", - "lineNumber": 0, - "columnNumber": 84752 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 121, - "ticks": 1 - } - ] - }, - { - "id": 712, - "callFrame": { - "functionName": "provideOriginalResource", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 572052 - }, - "hitCount": 0, - "children": [ - 713 - ] - }, - { - "id": 713, - "callFrame": { - "functionName": "", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 572979 - }, - "hitCount": 0, - "children": [ - 714 - ] - }, - { - "id": 714, - "callFrame": { - "functionName": "t.pathEquals", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 612361 - }, - "hitCount": 0, - "children": [ - 715 - ] - }, - { - "id": 715, - "callFrame": { - "functionName": "g", - "scriptId": "606", - "url": "piiRemoved/main.js", - "lineNumber": 1, - "columnNumber": 615963 - }, - "hitCount": 0, - "children": [ - 716 - ] - }, - { - "id": 716, - "callFrame": { - "functionName": "normalize", - "scriptId": "36", - "url": "node:path", - "lineNumber": 1253, - "columnNumber": 11 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 94, - "ticks": 1 - } - ] - }, - { - "id": 717, - "callFrame": { - "functionName": "_sendMessage", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 106, - "columnNumber": 12750 - }, - "hitCount": 0, - "children": [ - 718 - ] - }, - { - "id": 718, - "callFrame": { - "functionName": "send", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 106, - "columnNumber": 11645 - }, - "hitCount": 1, - "children": [ - 719 - ], - "positionTicks": [ - { - "line": 107, - "ticks": 1 - } - ] - }, - { - "id": 719, - "callFrame": { - "functionName": "send", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 37531 - }, - "hitCount": 0, - "children": [ - 720 - ] - }, - { - "id": 720, - "callFrame": { - "functionName": "send", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 26758 - }, - "hitCount": 0, - "children": [ - 721 - ] - }, - { - "id": 721, - "callFrame": { - "functionName": "dispatch", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 27894 - }, - "hitCount": 0, - "children": [ - 722, - 723 - ] - }, - { - "id": 722, - "callFrame": { - "functionName": "from", - "scriptId": "24", - "url": "node:buffer", - "lineNumber": 297, - "columnNumber": 27 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 298, - "ticks": 1 - } - ] - }, - { - "id": 723, - "callFrame": { - "functionName": "sendFrame", - "scriptId": "608", - "url": "piiRemoved/extension.js", - "lineNumber": 2, - "columnNumber": 28494 - }, - "hitCount": 0, - "children": [ - 724 - ] - }, - { - "id": 724, - "callFrame": { - "functionName": "Writable.uncork", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 519, - "columnNumber": 36 - }, - "hitCount": 0, - "children": [ - 725 - ] - }, - { - "id": 725, - "callFrame": { - "functionName": "clearBuffer", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 743, - "columnNumber": 20 - }, - "hitCount": 0, - "children": [ - 726 - ] - }, - { - "id": 726, - "callFrame": { - "functionName": "doWrite", - "scriptId": "108", - "url": "node:internal/streams/writable", - "lineNumber": 586, - "columnNumber": 16 - }, - "hitCount": 0, - "children": [ - 727 - ] - }, - { - "id": 727, - "callFrame": { - "functionName": "Socket._writev", - "scriptId": "94", - "url": "node:net", - "lineNumber": 971, - "columnNumber": 35 - }, - "hitCount": 0, - "children": [ - 728 - ] - }, - { - "id": 728, - "callFrame": { - "functionName": "Socket._writeGeneric", - "scriptId": "94", - "url": "node:net", - "lineNumber": 934, - "columnNumber": 41 - }, - "hitCount": 0, - "children": [ - 729 - ] - }, - { - "id": 729, - "callFrame": { - "functionName": "writevGeneric", - "scriptId": "113", - "url": "node:internal/stream_base_commons", - "lineNumber": 120, - "columnNumber": 22 - }, - "hitCount": 0, - "children": [ - 730 - ] - }, - { - "id": 730, - "callFrame": { - "functionName": "writev", - "scriptId": "0", - "url": "", - "lineNumber": -1, - "columnNumber": -1 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 137, - "ticks": 1 - } - ] - }, - { - "id": 758, - "callFrame": { - "functionName": "processPromiseRejections", - "scriptId": "31", - "url": "node:internal/process/promises", - "lineNumber": 438, - "columnNumber": 33 - }, - "hitCount": 1, - "positionTicks": [ - { - "line": 439, - "ticks": 1 - } - ] - } - ], - "startTime": 341592025292, - "endTime": 341603042126, - "samples": [ - 2, - 2, - 2, - 2, - 2, - 6, - 5, - 6, - 6, - 6, - 7, - 5, - 2, - 4, - 5, - 6, - 5, - 5, - 3, - 6, - 3, - 6, - 6, - 5, - 7, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 5, - 3, - 6, - 5, - 3, - 6, - 7, - 6, - 6, - 6, - 7, - 6, - 5, - 6, - 6, - 5, - 6, - 7, - 5, - 6, - 6, - 7, - 7, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 3, - 5, - 7, - 5, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 7, - 6, - 6, - 5, - 5, - 6, - 6, - 7, - 5, - 7, - 6, - 6, - 4, - 6, - 5, - 5, - 4, - 3, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 7, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 5, - 7, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 7, - 6, - 5, - 5, - 4, - 5, - 7, - 7, - 8, - 8, - 8, - 8, - 8, - 8, - 8, - 2, - 2, - 9, - 9, - 18, - 29, - 34, - 34, - 34, - 37, - 42, - 52, - 24, - 24, - 34, - 34, - 37, - 40, - 55, - 22, - 24, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 26, - 24, - 9, - 34, - 33, - 33, - 34, - 42, - 60, - 24, - 34, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 37, - 42, - 57, - 57, - 9, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 33, - 24, - 37, - 42, - 57, - 24, - 34, - 63, - 34, - 42, - 42, - 55, - 26, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 62, - 24, - 65, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 2, - 24, - 24, - 9, - 24, - 62, - 2, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 24, - 33, - 33, - 34, - 37, - 42, - 56, - 2, - 24, - 34, - 34, - 63, - 42, - 56, - 57, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 24, - 34, - 34, - 68, - 42, - 56, - 57, - 26, - 62, - 34, - 34, - 34, - 42, - 42, - 55, - 9, - 24, - 33, - 34, - 34, - 68, - 42, - 56, - 62, - 9, - 24, - 9, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 2, - 71, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 24, - 23, - 33, - 34, - 34, - 42, - 56, - 55, - 76, - 81, - 91, - 88, - 9, - 111, - 113, - 114, - 111, - 2, - 122, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 140, - 141, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 141, - 140, - 142, - 142, - 142, - 142, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 3, - 7, - 6, - 6, - 6, - 4, - 4, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 7, - 6, - 7, - 7, - 6, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 4, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 3, - 7, - 7, - 5, - 5, - 7, - 6, - 6, - 6, - 5, - 7, - 5, - 5, - 6, - 6, - 4, - 6, - 4, - 5, - 5, - 6, - 6, - 7, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 4, - 4, - 5, - 4, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 7, - 7, - 7, - 5, - 6, - 6, - 5, - 7, - 6, - 6, - 5, - 6, - 3, - 5, - 5, - 6, - 5, - 8, - 8, - 8, - 8, - 8, - 2, - 9, - 9, - 9, - 147, - 160, - 160, - 161, - 162, - 166, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 140, - 3, - 6, - 6, - 5, - 5, - 61, - 61, - 61, - 6, - 4, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 2, - 2, - 61, - 61, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 135, - 61, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 167, - 141, - 141, - 140, - 140, - 141, - 140, - 169, - 140, - 141, - 140, - 139, - 141, - 139, - 140, - 2, - 3, - 3, - 3, - 3, - 5, - 5, - 6, - 6, - 6, - 6, - 5, - 7, - 170, - 6, - 6, - 7, - 5, - 6, - 6, - 5, - 5, - 7, - 4, - 6, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 6, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 7, - 7, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 6, - 6, - 4, - 5, - 5, - 6, - 7, - 5, - 6, - 7, - 5, - 6, - 7, - 6, - 5, - 6, - 7, - 3, - 5, - 5, - 6, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 4, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 5, - 7, - 5, - 7, - 6, - 5, - 8, - 8, - 8, - 8, - 8, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 169, - 141, - 140, - 2, - 141, - 139, - 2, - 3, - 3, - 6, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 4, - 6, - 5, - 5, - 6, - 6, - 4, - 6, - 5, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 7, - 4, - 5, - 6, - 6, - 6, - 5, - 5, - 7, - 7, - 6, - 6, - 6, - 6, - 7, - 5, - 5, - 5, - 6, - 61, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 6, - 7, - 6, - 5, - 6, - 5, - 5, - 4, - 4, - 5, - 5, - 3, - 5, - 7, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 7, - 6, - 6, - 6, - 7, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 7, - 6, - 5, - 5, - 5, - 6, - 7, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 7, - 6, - 6, - 7, - 2, - 6, - 5, - 5, - 6, - 6, - 5, - 2, - 6, - 7, - 6, - 3, - 5, - 5, - 5, - 5, - 7, - 5, - 8, - 171, - 8, - 8, - 8, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 172, - 172, - 140, - 174, - 172, - 172, - 174, - 174, - 139, - 173, - 174, - 140, - 174, - 174, - 140, - 173, - 174, - 174, - 173, - 174, - 173, - 140, - 174, - 173, - 140, - 174, - 139, - 140, - 142, - 142, - 142, - 3, - 3, - 3, - 5, - 6, - 3, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 6, - 4, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 7, - 5, - 4, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 7, - 5, - 5, - 6, - 5, - 6, - 7, - 3, - 2, - 6, - 6, - 7, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 4, - 5, - 6, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 7, - 5, - 4, - 7, - 5, - 6, - 2, - 6, - 5, - 6, - 6, - 4, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 5, - 7, - 7, - 61, - 5, - 5, - 6, - 2, - 5, - 6, - 6, - 5, - 3, - 7, - 7, - 6, - 7, - 5, - 5, - 4, - 5, - 6, - 4, - 6, - 7, - 5, - 6, - 8, - 8, - 8, - 8, - 175, - 9, - 9, - 189, - 197, - 213, - 214, - 216, - 220, - 220, - 224, - 226, - 9, - 227, - 229, - 229, - 233, - 235, - 198, - 229, - 236, - 237, - 227, - 229, - 238, - 226, - 219, - 240, - 226, - 24, - 63, - 33, - 34, - 37, - 42, - 56, - 57, - 2, - 2, - 26, - 24, - 33, - 34, - 34, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 243, - 55, - 62, - 9, - 24, - 34, - 33, - 34, - 37, - 42, - 60, - 57, - 24, - 62, - 34, - 34, - 33, - 68, - 42, - 55, - 9, - 2, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 60, - 26, - 24, - 62, - 34, - 34, - 42, - 56, - 57, - 2, - 2, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 24, - 2, - 2, - 63, - 34, - 33, - 34, - 37, - 42, - 60, - 24, - 24, - 62, - 34, - 63, - 34, - 37, - 56, - 2, - 34, - 34, - 37, - 56, - 55, - 24, - 24, - 33, - 33, - 33, - 37, - 42, - 56, - 57, - 24, - 24, - 24, - 34, - 34, - 63, - 68, - 42, - 56, - 57, - 9, - 71, - 62, - 33, - 34, - 63, - 42, - 56, - 57, - 26, - 34, - 33, - 33, - 37, - 56, - 55, - 31, - 26, - 62, - 33, - 34, - 37, - 42, - 60, - 31, - 9, - 24, - 34, - 34, - 63, - 42, - 60, - 57, - 26, - 62, - 34, - 34, - 34, - 42, - 45, - 245, - 62, - 34, - 34, - 34, - 42, - 42, - 52, - 57, - 2, - 34, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 57, - 9, - 26, - 31, - 34, - 34, - 34, - 24, - 42, - 55, - 24, - 10, - 62, - 34, - 33, - 34, - 63, - 42, - 56, - 55, - 24, - 24, - 24, - 24, - 34, - 34, - 68, - 42, - 56, - 57, - 2, - 2, - 62, - 33, - 33, - 34, - 37, - 42, - 56, - 62, - 246, - 254, - 2, - 275, - 279, - 288, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 290, - 139, - 169, - 139, - 169, - 139, - 169, - 140, - 169, - 169, - 140, - 141, - 140, - 140, - 169, - 169, - 139, - 139, - 140, - 140, - 139, - 140, - 139, - 142, - 142, - 2, - 2, - 2, - 2, - 2, - 2, - 3, - 2, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 6, - 7, - 5, - 5, - 5, - 5, - 6, - 291, - 2, - 5, - 5, - 3, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 7, - 4, - 5, - 5, - 5, - 6, - 6, - 5, - 4, - 4, - 5, - 5, - 5, - 5, - 3, - 5, - 6, - 6, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 3, - 6, - 7, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 2, - 6, - 6, - 6, - 6, - 6, - 7, - 5, - 4, - 4, - 6, - 6, - 5, - 5, - 6, - 5, - 7, - 6, - 6, - 7, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 5, - 6, - 6, - 5, - 6, - 7, - 5, - 3, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 5, - 8, - 8, - 171, - 8, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 169, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 140, - 169, - 140, - 140, - 142, - 142, - 142, - 2, - 3, - 3, - 3, - 3, - 3, - 5, - 6, - 6, - 6, - 7, - 5, - 3, - 6, - 7, - 6, - 5, - 5, - 5, - 7, - 5, - 4, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 7, - 7, - 5, - 4, - 6, - 6, - 6, - 5, - 6, - 5, - 7, - 170, - 7, - 6, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 3, - 6, - 5, - 6, - 5, - 5, - 6, - 2, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 6, - 3, - 5, - 5, - 6, - 5, - 7, - 5, - 6, - 5, - 5, - 5, - 4, - 4, - 6, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 5, - 7, - 6, - 5, - 7, - 5, - 6, - 5, - 5, - 5, - 4, - 5, - 5, - 6, - 4, - 6, - 5, - 4, - 6, - 5, - 6, - 5, - 5, - 7, - 6, - 5, - 7, - 6, - 7, - 5, - 5, - 7, - 5, - 6, - 170, - 6, - 7, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 8, - 8, - 8, - 8, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 140, - 139, - 140, - 140, - 169, - 139, - 140, - 169, - 139, - 139, - 169, - 139, - 140, - 139, - 139, - 140, - 169, - 142, - 142, - 142, - 3, - 2, - 3, - 7, - 5, - 5, - 6, - 7, - 6, - 7, - 7, - 5, - 6, - 6, - 7, - 6, - 5, - 4, - 6, - 6, - 5, - 6, - 5, - 5, - 7, - 7, - 6, - 5, - 5, - 5, - 7, - 6, - 7, - 6, - 6, - 6, - 6, - 7, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 2, - 6, - 5, - 7, - 5, - 5, - 5, - 7, - 3, - 7, - 6, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 6, - 6, - 5, - 7, - 5, - 6, - 3, - 6, - 2, - 6, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 4, - 6, - 6, - 5, - 7, - 5, - 6, - 4, - 3, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 3, - 6, - 2, - 7, - 6, - 6, - 5, - 3, - 3, - 5, - 7, - 7, - 6, - 6, - 5, - 6, - 6, - 6, - 7, - 5, - 7, - 6, - 5, - 5, - 5, - 5, - 4, - 5, - 6, - 3, - 7, - 5, - 7, - 5, - 7, - 6, - 5, - 6, - 8, - 171, - 8, - 9, - 9, - 293, - 295, - 301, - 236, - 303, - 306, - 307, - 308, - 150, - 309, - 162, - 9, - 160, - 162, - 33, - 63, - 34, - 36, - 42, - 57, - 71, - 33, - 63, - 34, - 37, - 310, - 57, - 26, - 62, - 34, - 34, - 313, - 24, - 33, - 34, - 42, - 56, - 24, - 22, - 24, - 34, - 34, - 42, - 60, - 9, - 33, - 26, - 33, - 34, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 24, - 62, - 34, - 34, - 34, - 42, - 57, - 9, - 33, - 34, - 63, - 42, - 56, - 24, - 24, - 33, - 34, - 42, - 56, - 55, - 26, - 31, - 34, - 34, - 42, - 62, - 24, - 62, - 63, - 34, - 34, - 37, - 56, - 24, - 24, - 62, - 34, - 34, - 36, - 56, - 55, - 9, - 34, - 33, - 34, - 42, - 57, - 62, - 26, - 62, - 31, - 34, - 34, - 42, - 55, - 62, - 2, - 316, - 323, - 326, - 81, - 80, - 82, - 332, - 107, - 9, - 162, - 182, - 229, - 306, - 9, - 9, - 9, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 142, - 3, - 2, - 5, - 6, - 6, - 6, - 5, - 5, - 7, - 6, - 5, - 5, - 5, - 6, - 7, - 5, - 5, - 7, - 6, - 4, - 6, - 7, - 5, - 5, - 5, - 6, - 7, - 7, - 7, - 6, - 5, - 5, - 7, - 6, - 5, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 5, - 6, - 6, - 5, - 4, - 7, - 6, - 5, - 7, - 7, - 6, - 6, - 5, - 5, - 5, - 5, - 2, - 6, - 6, - 6, - 3, - 5, - 3, - 6, - 5, - 5, - 4, - 6, - 170, - 6, - 5, - 5, - 5, - 7, - 4, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 2, - 7, - 6, - 5, - 7, - 5, - 7, - 5, - 3, - 5, - 5, - 6, - 61, - 61, - 56, - 62, - 135, - 135, - 61, - 61, - 5, - 7, - 62, - 9, - 135, - 135, - 135, - 135, - 139, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 2, - 6, - 4, - 3, - 6, - 5, - 5, - 6, - 6, - 4, - 6, - 5, - 5, - 3, - 7, - 5, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 7, - 6, - 4, - 6, - 5, - 6, - 5, - 6, - 6, - 7, - 3, - 7, - 6, - 6, - 5, - 6, - 4, - 3, - 5, - 5, - 6, - 8, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 141, - 169, - 139, - 139, - 140, - 3, - 3, - 6, - 5, - 6, - 5, - 6, - 6, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 138, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 3, - 3, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 7, - 2, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 4, - 3, - 5, - 6, - 6, - 7, - 5, - 6, - 6, - 5, - 5, - 4, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 4, - 3, - 5, - 5, - 5, - 9, - 62, - 24, - 26, - 33, - 34, - 34, - 34, - 42, - 56, - 57, - 61, - 61, - 56, - 62, - 34, - 56, - 57, - 62, - 34, - 34, - 34, - 56, - 55, - 23, - 34, - 37, - 42, - 55, - 62, - 62, - 33, - 68, - 68, - 37, - 56, - 57, - 26, - 34, - 34, - 34, - 42, - 245, - 62, - 24, - 34, - 34, - 37, - 333, - 56, - 62, - 26, - 62, - 34, - 34, - 24, - 42, - 55, - 62, - 34, - 34, - 33, - 42, - 56, - 55, - 24, - 2, - 336, - 343, - 345, - 345, - 346, - 26, - 62, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 350, - 351, - 353, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 140, - 139, - 139, - 169, - 169, - 140, - 140, - 140, - 139, - 169, - 169, - 169, - 140, - 139, - 169, - 140, - 139, - 140, - 140, - 139, - 140, - 139, - 139, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 5, - 2, - 5, - 5, - 5, - 4, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 6, - 7, - 5, - 7, - 5, - 5, - 6, - 7, - 7, - 4, - 5, - 5, - 7, - 4, - 5, - 6, - 3, - 5, - 5, - 6, - 6, - 3, - 6, - 5, - 6, - 6, - 6, - 4, - 5, - 6, - 5, - 5, - 4, - 6, - 5, - 5, - 4, - 5, - 7, - 6, - 5, - 5, - 6, - 5, - 3, - 5, - 6, - 7, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 4, - 7, - 6, - 4, - 5, - 5, - 6, - 3, - 4, - 7, - 7, - 5, - 6, - 2, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 6, - 6, - 4, - 6, - 6, - 6, - 5, - 6, - 6, - 7, - 5, - 5, - 5, - 6, - 6, - 7, - 5, - 6, - 7, - 6, - 5, - 5, - 6, - 7, - 5, - 5, - 6, - 7, - 5, - 5, - 5, - 5, - 6, - 6, - 7, - 4, - 7, - 5, - 5, - 354, - 8, - 8, - 8, - 9, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 169, - 140, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 140, - 139, - 169, - 140, - 139, - 140, - 140, - 139, - 142, - 142, - 142, - 2, - 3, - 3, - 3, - 3, - 6, - 4, - 6, - 6, - 6, - 6, - 4, - 5, - 7, - 3, - 5, - 7, - 5, - 5, - 6, - 5, - 7, - 6, - 6, - 6, - 7, - 6, - 6, - 5, - 6, - 4, - 6, - 5, - 2, - 2, - 6, - 5, - 6, - 5, - 3, - 5, - 5, - 7, - 6, - 6, - 3, - 6, - 4, - 6, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 4, - 7, - 6, - 7, - 6, - 5, - 6, - 6, - 5, - 7, - 7, - 5, - 6, - 5, - 5, - 6, - 4, - 7, - 2, - 7, - 5, - 2, - 5, - 3, - 6, - 6, - 5, - 4, - 5, - 6, - 5, - 5, - 5, - 5, - 7, - 4, - 5, - 5, - 6, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 4, - 6, - 6, - 6, - 5, - 7, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 7, - 6, - 6, - 6, - 6, - 4, - 4, - 5, - 5, - 5, - 6, - 6, - 4, - 8, - 8, - 8, - 355, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 169, - 169, - 139, - 140, - 140, - 139, - 169, - 140, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 139, - 140, - 140, - 140, - 139, - 139, - 140, - 169, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 142, - 142, - 142, - 3, - 2, - 3, - 2, - 3, - 5, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 6, - 7, - 5, - 5, - 6, - 5, - 6, - 7, - 4, - 6, - 4, - 7, - 6, - 6, - 5, - 6, - 5, - 5, - 7, - 4, - 5, - 5, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 7, - 2, - 6, - 6, - 6, - 5, - 7, - 7, - 4, - 6, - 5, - 5, - 6, - 7, - 7, - 5, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 3, - 5, - 5, - 5, - 6, - 5, - 4, - 7, - 5, - 4, - 5, - 6, - 5, - 6, - 5, - 7, - 6, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 3, - 5, - 6, - 6, - 7, - 5, - 2, - 6, - 6, - 5, - 5, - 8, - 8, - 354, - 8, - 2, - 9, - 9, - 2, - 235, - 227, - 213, - 180, - 356, - 226, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 139, - 139, - 140, - 140, - 139, - 169, - 139, - 139, - 139, - 139, - 140, - 169, - 139, - 140, - 140, - 140, - 169, - 139, - 140, - 139, - 139, - 140, - 142, - 142, - 142, - 3, - 3, - 3, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 7, - 7, - 6, - 5, - 5, - 6, - 7, - 6, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 6, - 7, - 7, - 5, - 6, - 5, - 4, - 5, - 7, - 6, - 5, - 7, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 7, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 3, - 5, - 5, - 6, - 4, - 5, - 6, - 7, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 7, - 5, - 5, - 5, - 6, - 4, - 5, - 6, - 6, - 4, - 5, - 5, - 7, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 7, - 5, - 4, - 6, - 7, - 5, - 170, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 7, - 5, - 5, - 2, - 5, - 4, - 5, - 6, - 354, - 8, - 171, - 171, - 355, - 9, - 9, - 9, - 34, - 34, - 34, - 63, - 37, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 55, - 62, - 24, - 62, - 34, - 33, - 63, - 42, - 56, - 55, - 9, - 31, - 24, - 34, - 34, - 68, - 42, - 55, - 26, - 62, - 34, - 34, - 34, - 42, - 39, - 55, - 26, - 31, - 34, - 34, - 34, - 42, - 42, - 55, - 62, - 357, - 24, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 9, - 24, - 34, - 34, - 34, - 42, - 56, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 2, - 71, - 24, - 34, - 34, - 34, - 68, - 56, - 55, - 24, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 24, - 33, - 33, - 34, - 37, - 56, - 55, - 24, - 62, - 34, - 34, - 33, - 36, - 42, - 245, - 62, - 26, - 62, - 34, - 34, - 34, - 42, - 52, - 62, - 62, - 34, - 63, - 34, - 63, - 37, - 42, - 60, - 62, - 33, - 34, - 34, - 37, - 42, - 55, - 26, - 34, - 34, - 33, - 34, - 42, - 56, - 62, - 26, - 24, - 34, - 34, - 37, - 42, - 363, - 24, - 24, - 26, - 62, - 34, - 34, - 63, - 37, - 42, - 56, - 55, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 113, - 109, - 367, - 9, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 140, - 139, - 140, - 140, - 140, - 169, - 140, - 139, - 169, - 140, - 169, - 169, - 139, - 139, - 169, - 140, - 139, - 140, - 139, - 140, - 139, - 142, - 142, - 2, - 2, - 3, - 3, - 3, - 3, - 3, - 3, - 3, - 3, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 7, - 7, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 7, - 6, - 5, - 5, - 6, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 7, - 5, - 6, - 7, - 5, - 5, - 7, - 6, - 5, - 4, - 5, - 7, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 6, - 2, - 6, - 5, - 6, - 6, - 5, - 7, - 7, - 4, - 7, - 6, - 5, - 4, - 6, - 5, - 6, - 6, - 6, - 5, - 3, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 6, - 5, - 7, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 7, - 4, - 5, - 5, - 6, - 4, - 61, - 140, - 3, - 3, - 4, - 5, - 61, - 7, - 61, - 3, - 61, - 61, - 61, - 5, - 6, - 61, - 61, - 5, - 6, - 5, - 7, - 4, - 7, - 61, - 61, - 61, - 4, - 5, - 61, - 5, - 6, - 5, - 6, - 5, - 5, - 7, - 7, - 5, - 61, - 4, - 61, - 5, - 7, - 6, - 5, - 4, - 5, - 5, - 7, - 7, - 5, - 7, - 61, - 6, - 6, - 5, - 5, - 5, - 4, - 5, - 5, - 3, - 5, - 5, - 4, - 6, - 5, - 6, - 7, - 6, - 5, - 5, - 5, - 5, - 61, - 8, - 354, - 8, - 8, - 8, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 9, - 33, - 61, - 61, - 33, - 34, - 33, - 61, - 42, - 42, - 56, - 363, - 33, - 61, - 61, - 33, - 61, - 42, - 42, - 56, - 57, - 24, - 24, - 33, - 33, - 61, - 34, - 34, - 34, - 33, - 34, - 33, - 34, - 63, - 68, - 37, - 37, - 61, - 57, - 9, - 26, - 24, - 68, - 24, - 34, - 61, - 61, - 37, - 42, - 56, - 34, - 34, - 33, - 61, - 2, - 37, - 34, - 52, - 34, - 34, - 63, - 34, - 33, - 61, - 24, - 34, - 61, - 37, - 42, - 34, - 63, - 33, - 37, - 37, - 42, - 42, - 61, - 42, - 56, - 57, - 37, - 61, - 42, - 42, - 42, - 24, - 61, - 33, - 61, - 33, - 34, - 33, - 61, - 61, - 34, - 33, - 34, - 57, - 61, - 63, - 61, - 61, - 61, - 61, - 56, - 57, - 2, - 71, - 62, - 34, - 34, - 63, - 33, - 37, - 42, - 40, - 363, - 24, - 61, - 22, - 71, - 31, - 24, - 369, - 33, - 61, - 34, - 61, - 63, - 61, - 61, - 37, - 42, - 61, - 42, - 61, - 363, - 57, - 9, - 26, - 24, - 34, - 63, - 33, - 24, - 61, - 42, - 61, - 363, - 24, - 9, - 22, - 26, - 31, - 34, - 33, - 61, - 61, - 34, - 37, - 42, - 61, - 363, - 55, - 62, - 2, - 376, - 377, - 22, - 24, - 31, - 378, - 389, - 2, - 147, - 160, - 162, - 162, - 165, - 61, - 61, - 62, - 33, - 34, - 34, - 33, - 34, - 62, - 26, - 63, - 61, - 33, - 33, - 61, - 34, - 37, - 42, - 56, - 363, - 24, - 33, - 63, - 34, - 34, - 37, - 333, - 56, - 55, - 61, - 61, - 33, - 34, - 63, - 34, - 37, - 42, - 61, - 56, - 363, - 61, - 34, - 61, - 61, - 52, - 26, - 37, - 57, - 24, - 61, - 61, - 61, - 333, - 57, - 31, - 61, - 61, - 63, - 34, - 61, - 34, - 33, - 34, - 42, - 56, - 61, - 24, - 9, - 2, - 2, - 24, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 63, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 61, - 42, - 61, - 52, - 57, - 65, - 33, - 34, - 34, - 37, - 42, - 52, - 55, - 24, - 24, - 61, - 61, - 34, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 63, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 52, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 363, - 245, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 22, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 37, - 42, - 55, - 24, - 2, - 34, - 63, - 34, - 37, - 56, - 55, - 9, - 24, - 33, - 63, - 34, - 37, - 42, - 56, - 34, - 34, - 34, - 34, - 36, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 63, - 390, - 42, - 56, - 62, - 62, - 34, - 34, - 37, - 34, - 34, - 34, - 34, - 42, - 42, - 57, - 392, - 9, - 9, - 393, - 195, - 229, - 235, - 9, - 9, - 26, - 63, - 33, - 24, - 34, - 34, - 37, - 42, - 52, - 57, - 24, - 2, - 24, - 34, - 34, - 34, - 37, - 52, - 24, - 2, - 62, - 34, - 34, - 33, - 61, - 42, - 42, - 42, - 22, - 34, - 33, - 34, - 34, - 42, - 56, - 57, - 62, - 33, - 34, - 34, - 37, - 60, - 62, - 24, - 24, - 34, - 34, - 24, - 24, - 31, - 34, - 34, - 34, - 42, - 56, - 245, - 57, - 23, - 2, - 24, - 62, - 34, - 34, - 33, - 42, - 56, - 55, - 62, - 24, - 62, - 33, - 63, - 34, - 24, - 42, - 56, - 57, - 26, - 24, - 62, - 34, - 34, - 24, - 37, - 42, - 56, - 55, - 327, - 62, - 34, - 34, - 34, - 42, - 56, - 62, - 34, - 34, - 42, - 55, - 62, - 396, - 394, - 233, - 9, - 182, - 229, - 232, - 237, - 9, - 9, - 24, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 63, - 42, - 56, - 55, - 24, - 24, - 62, - 34, - 63, - 34, - 42, - 56, - 57, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 22, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 2, - 62, - 34, - 33, - 34, - 36, - 42, - 56, - 363, - 57, - 24, - 24, - 33, - 34, - 34, - 68, - 42, - 56, - 24, - 24, - 26, - 34, - 33, - 33, - 34, - 42, - 56, - 56, - 57, - 24, - 9, - 33, - 34, - 34, - 33, - 37, - 42, - 52, - 57, - 62, - 24, - 24, - 34, - 33, - 37, - 42, - 42, - 56, - 363, - 24, - 65, - 62, - 31, - 34, - 34, - 34, - 397, - 42, - 56, - 57, - 21, - 24, - 62, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 24, - 62, - 2, - 24, - 33, - 63, - 34, - 34, - 42, - 56, - 56, - 57, - 313, - 24, - 62, - 34, - 34, - 34, - 33, - 42, - 56, - 52, - 57, - 31, - 26, - 62, - 34, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 55, - 10, - 9, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 62, - 26, - 34, - 63, - 34, - 37, - 42, - 52, - 57, - 24, - 34, - 24, - 33, - 37, - 42, - 56, - 62, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 19, - 62, - 33, - 34, - 33, - 34, - 42, - 42, - 52, - 62, - 9, - 62, - 34, - 34, - 34, - 37, - 44, - 52, - 23, - 2, - 62, - 34, - 33, - 34, - 37, - 42, - 44, - 363, - 57, - 24, - 26, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 62, - 9, - 24, - 34, - 34, - 33, - 68, - 42, - 56, - 55, - 24, - 62, - 26, - 34, - 34, - 34, - 24, - 42, - 56, - 55, - 62, - 22, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 60, - 62, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 22, - 33, - 34, - 34, - 36, - 42, - 52, - 62, - 62, - 26, - 24, - 26, - 24, - 34, - 33, - 34, - 68, - 42, - 56, - 245, - 37, - 42, - 55, - 62, - 398, - 403, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 405, - 141, - 140, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 141, - 141, - 169, - 139, - 139, - 139, - 172, - 172, - 172, - 172, - 139, - 140, - 172, - 139, - 139, - 172, - 172, - 172, - 172, - 172, - 140, - 172, - 172, - 172, - 139, - 174, - 172, - 172, - 139, - 172, - 172, - 172, - 173, - 172, - 173, - 172, - 140, - 172, - 142, - 142, - 142, - 142, - 3, - 3, - 5, - 6, - 5, - 6, - 7, - 5, - 5, - 4, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 6, - 6, - 4, - 6, - 6, - 3, - 5, - 4, - 5, - 2, - 5, - 4, - 6, - 4, - 5, - 6, - 7, - 5, - 6, - 5, - 6, - 6, - 6, - 4, - 6, - 6, - 6, - 5, - 6, - 7, - 5, - 5, - 6, - 170, - 5, - 7, - 6, - 4, - 5, - 6, - 6, - 6, - 7, - 5, - 5, - 7, - 6, - 6, - 6, - 6, - 6, - 4, - 3, - 7, - 6, - 5, - 6, - 5, - 7, - 6, - 7, - 5, - 7, - 5, - 7, - 5, - 8, - 2, - 33, - 24, - 34, - 61, - 42, - 61, - 3, - 6, - 5, - 4, - 5, - 6, - 6, - 6, - 6, - 6, - 5, - 6, - 7, - 24, - 34, - 24, - 34, - 63, - 34, - 37, - 56, - 57, - 62, - 63, - 33, - 34, - 34, - 42, - 56, - 9, - 62, - 34, - 34, - 33, - 33, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 68, - 42, - 407, - 26, - 55, - 24, - 22, - 62, - 40, - 55, - 57, - 24, - 9, - 31, - 62, - 34, - 34, - 33, - 34, - 33, - 33, - 37, - 42, - 56, - 55, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 42, - 56, - 2, - 135, - 135, - 135, - 135, - 135, - 140, - 139, - 140, - 140, - 3, - 5, - 6, - 6, - 7, - 6, - 5, - 6, - 4, - 5, - 5, - 7, - 7, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 170, - 4, - 6, - 5, - 6, - 7, - 6, - 6, - 7, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 3, - 7, - 3, - 5, - 4, - 5, - 6, - 6, - 5, - 7, - 7, - 5, - 6, - 6, - 5, - 7, - 5, - 7, - 2, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 7, - 6, - 6, - 6, - 6, - 6, - 5, - 4, - 7, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 8, - 8, - 8, - 171, - 2, - 9, - 9, - 2, - 408, - 412, - 162, - 162, - 413, - 26, - 34, - 33, - 34, - 42, - 56, - 57, - 24, - 26, - 55, - 26, - 24, - 34, - 34, - 37, - 42, - 33, - 68, - 42, - 56, - 55, - 415, - 24, - 62, - 34, - 34, - 33, - 68, - 42, - 56, - 24, - 26, - 24, - 42, - 55, - 9, - 63, - 33, - 34, - 61, - 61, - 61, - 61, - 9, - 56, - 57, - 24, - 26, - 390, - 42, - 52, - 9, - 34, - 34, - 34, - 42, - 62, - 24, - 34, - 63, - 56, - 2, - 26, - 34, - 33, - 68, - 52, - 422, - 425, - 425, - 425, - 425, - 426, - 427, - 427, - 446, - 449, - 455, - 351, - 366, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 2, - 22, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 57, - 62, - 26, - 467, - 140, - 7, - 5, - 6, - 6, - 7, - 4, - 4, - 7, - 7, - 5, - 6, - 7, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 6, - 6, - 7, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 7, - 3, - 3, - 5, - 6, - 5, - 6, - 5, - 5, - 4, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 8, - 8, - 354, - 354, - 9, - 2, - 9, - 167, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 124, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 140, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 141, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 169, - 140, - 169, - 169, - 140, - 139, - 142, - 142, - 142, - 142, - 2, - 3, - 3, - 7, - 7, - 6, - 5, - 5, - 5, - 5, - 7, - 7, - 5, - 5, - 170, - 5, - 7, - 6, - 6, - 6, - 5, - 5, - 6, - 4, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 7, - 7, - 4, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 7, - 4, - 5, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 7, - 6, - 5, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 4, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 7, - 5, - 6, - 5, - 5, - 5, - 7, - 6, - 6, - 7, - 5, - 5, - 7, - 5, - 5, - 6, - 5, - 6, - 3, - 6, - 4, - 3, - 3, - 7, - 5, - 5, - 4, - 8, - 8, - 8, - 8, - 8, - 9, - 469, - 470, - 167, - 471, - 472, - 229, - 147, - 308, - 217, - 65, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 62, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 62, - 62, - 24, - 34, - 33, - 34, - 42, - 56, - 57, - 33, - 34, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 42, - 42, - 56, - 57, - 62, - 24, - 26, - 24, - 34, - 63, - 34, - 34, - 40, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 42, - 55, - 24, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 33, - 33, - 34, - 63, - 42, - 56, - 52, - 24, - 22, - 62, - 24, - 24, - 62, - 34, - 34, - 33, - 333, - 61, - 245, - 24, - 62, - 34, - 33, - 34, - 42, - 56, - 363, - 62, - 24, - 34, - 33, - 33, - 42, - 56, - 57, - 62, - 26, - 33, - 63, - 34, - 37, - 42, - 52, - 62, - 24, - 113, - 367, - 480, - 485, - 160, - 162, - 393, - 205, - 233, - 237, - 26, - 62, - 34, - 34, - 34, - 42, - 55, - 22, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 34, - 2, - 34, - 34, - 68, - 56, - 55, - 24, - 26, - 24, - 62, - 63, - 34, - 37, - 42, - 55, - 24, - 34, - 34, - 37, - 42, - 56, - 24, - 62, - 62, - 24, - 63, - 34, - 34, - 71, - 34, - 57, - 26, - 62, - 56, - 34, - 24, - 63, - 37, - 42, - 24, - 33, - 37, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 34, - 34, - 34, - 34, - 56, - 57, - 34, - 34, - 56, - 24, - 2, - 24, - 26, - 62, - 63, - 34, - 37, - 42, - 60, - 62, - 24, - 33, - 34, - 34, - 68, - 42, - 62, - 34, - 34, - 333, - 24, - 24, - 57, - 2, - 34, - 34, - 37, - 56, - 57, - 24, - 34, - 56, - 57, - 33, - 34, - 42, - 56, - 57, - 24, - 34, - 34, - 34, - 333, - 56, - 57, - 9, - 62, - 34, - 63, - 42, - 56, - 24, - 9, - 33, - 34, - 42, - 57, - 34, - 34, - 56, - 37, - 56, - 407, - 62, - 56, - 62, - 62, - 62, - 62, - 56, - 62, - 34, - 9, - 2, - 42, - 57, - 9, - 34, - 42, - 56, - 24, - 24, - 34, - 34, - 37, - 56, - 34, - 63, - 34, - 42, - 62, - 34, - 33, - 37, - 56, - 62, - 34, - 34, - 42, - 55, - 313, - 111, - 9, - 34, - 56, - 57, - 37, - 56, - 34, - 42, - 55, - 62, - 24, - 34, - 34, - 34, - 363, - 34, - 33, - 33, - 55, - 62, - 71, - 24, - 34, - 34, - 37, - 42, - 34, - 34, - 42, - 63, - 2, - 34, - 33, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 55, - 24, - 9, - 24, - 34, - 34, - 42, - 60, - 26, - 24, - 34, - 34, - 56, - 57, - 9, - 62, - 34, - 34, - 56, - 57, - 24, - 56, - 62, - 2, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 140, - 139, - 139, - 169, - 169, - 169, - 140, - 169, - 169, - 139, - 140, - 139, - 140, - 140, - 169, - 139, - 141, - 139, - 140, - 139, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 7, - 5, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 3, - 6, - 5, - 6, - 4, - 6, - 6, - 6, - 5, - 6, - 5, - 7, - 5, - 5, - 5, - 5, - 4, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 7, - 4, - 5, - 6, - 7, - 5, - 7, - 6, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 486, - 5, - 6, - 6, - 6, - 7, - 5, - 4, - 5, - 5, - 6, - 6, - 170, - 5, - 6, - 5, - 6, - 6, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 6, - 6, - 6, - 3, - 5, - 7, - 5, - 7, - 7, - 5, - 6, - 6, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 6, - 5, - 5, - 2, - 6, - 7, - 7, - 5, - 6, - 5, - 5, - 354, - 8, - 8, - 2, - 9, - 24, - 2, - 26, - 62, - 24, - 26, - 62, - 34, - 34, - 34, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 139, - 3, - 5, - 7, - 5, - 4, - 6, - 5, - 5, - 7, - 5, - 5, - 7, - 4, - 6, - 6, - 5, - 7, - 5, - 7, - 5, - 5, - 7, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 3, - 7, - 6, - 6, - 7, - 6, - 5, - 3, - 6, - 5, - 3, - 6, - 7, - 5, - 170, - 5, - 4, - 6, - 7, - 6, - 6, - 5, - 5, - 4, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 3, - 7, - 6, - 7, - 4, - 6, - 5, - 6, - 3, - 5, - 6, - 6, - 5, - 4, - 5, - 6, - 7, - 5, - 7, - 4, - 6, - 6, - 6, - 7, - 5, - 5, - 7, - 7, - 2, - 5, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 5, - 5, - 3, - 6, - 8, - 171, - 171, - 8, - 2, - 9, - 488, - 147, - 489, - 160, - 162, - 162, - 490, - 2, - 9, - 9, - 24, - 63, - 33, - 34, - 34, - 42, - 56, - 55, - 62, - 24, - 34, - 33, - 33, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 55, - 26, - 9, - 33, - 57, - 62, - 22, - 24, - 34, - 34, - 34, - 42, - 62, - 34, - 37, - 56, - 34, - 2, - 24, - 26, - 34, - 34, - 56, - 62, - 34, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 125, - 491, - 199, - 226, - 9, - 34, - 24, - 62, - 62, - 34, - 33, - 42, - 56, - 26, - 34, - 34, - 42, - 55, - 24, - 26, - 63, - 34, - 33, - 37, - 42, - 55, - 22, - 34, - 34, - 42, - 56, - 24, - 33, - 34, - 34, - 38, - 42, - 52, - 57, - 34, - 34, - 34, - 42, - 60, - 31, - 22, - 34, - 63, - 34, - 42, - 57, - 26, - 62, - 63, - 33, - 34, - 24, - 42, - 55, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 26, - 24, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 62, - 2, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 62, - 33, - 56, - 62, - 26, - 24, - 24, - 34, - 34, - 34, - 42, - 52, - 9, - 233, - 499, - 113, - 366, - 9, - 26, - 24, - 26, - 24, - 62, - 34, - 34, - 34, - 68, - 42, - 60, - 62, - 62, - 34, - 63, - 63, - 42, - 56, - 55, - 24, - 65, - 62, - 34, - 34, - 34, - 68, - 42, - 57, - 9, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 62, - 26, - 63, - 34, - 42, - 56, - 55, - 327, - 24, - 63, - 34, - 37, - 42, - 245, - 24, - 33, - 34, - 34, - 68, - 56, - 52, - 24, - 62, - 71, - 34, - 34, - 34, - 68, - 42, - 55, - 9, - 34, - 62, - 33, - 63, - 34, - 24, - 56, - 55, - 9, - 24, - 34, - 34, - 42, - 56, - 55, - 62, - 24, - 34, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 62, - 62, - 2, - 409, - 159, - 162, - 157, - 147, - 159, - 162, - 24, - 34, - 2, - 34, - 34, - 55, - 2, - 56, - 9, - 62, - 34, - 42, - 24, - 68, - 34, - 9, - 34, - 42, - 33, - 24, - 34, - 55, - 34, - 34, - 2, - 33, - 34, - 61, - 9, - 2, - 2, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 169, - 172, - 140, - 139, - 2, - 6, - 5, - 6, - 6, - 6, - 6, - 6, - 4, - 5, - 6, - 4, - 6, - 5, - 6, - 4, - 6, - 5, - 6, - 6, - 5, - 6, - 7, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 2, - 2, - 7, - 5, - 6, - 6, - 4, - 6, - 7, - 4, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 333, - 56, - 57, - 2, - 71, - 34, - 34, - 34, - 24, - 34, - 34, - 33, - 42, - 55, - 42, - 55, - 34, - 34, - 62, - 26, - 33, - 34, - 68, - 42, - 55, - 24, - 24, - 62, - 34, - 37, - 42, - 56, - 55, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 2, - 62, - 63, - 34, - 37, - 42, - 56, - 62, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 9, - 9, - 9, - 227, - 147, - 306, - 237, - 500, - 24, - 62, - 34, - 34, - 34, - 33, - 42, - 56, - 55, - 26, - 62, - 34, - 34, - 24, - 45, - 55, - 62, - 22, - 34, - 34, - 33, - 42, - 56, - 57, - 24, - 9, - 24, - 34, - 34, - 34, - 33, - 42, - 56, - 57, - 62, - 24, - 63, - 34, - 34, - 42, - 56, - 62, - 24, - 34, - 34, - 33, - 42, - 56, - 24, - 33, - 34, - 24, - 501, - 24, - 34, - 33, - 42, - 42, - 42, - 57, - 9, - 24, - 34, - 34, - 34, - 37, - 24, - 9, - 62, - 34, - 34, - 42, - 56, - 55, - 62, - 34, - 34, - 37, - 56, - 55, - 24, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 34, - 34, - 24, - 34, - 52, - 62, - 9, - 63, - 22, - 24, - 34, - 37, - 24, - 26, - 24, - 62, - 62, - 33, - 36, - 57, - 34, - 63, - 37, - 62, - 26, - 31, - 34, - 34, - 33, - 56, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 57, - 22, - 24, - 34, - 33, - 33, - 42, - 55, - 62, - 26, - 62, - 34, - 34, - 42, - 56, - 57, - 2, - 62, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 9, - 31, - 34, - 34, - 34, - 42, - 245, - 24, - 24, - 24, - 62, - 34, - 34, - 42, - 56, - 55, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 71, - 24, - 34, - 33, - 34, - 24, - 42, - 60, - 24, - 71, - 33, - 34, - 33, - 34, - 37, - 42, - 56, - 62, - 24, - 71, - 62, - 9, - 62, - 2, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 26, - 34, - 34, - 34, - 68, - 42, - 55, - 24, - 34, - 34, - 34, - 36, - 56, - 57, - 24, - 34, - 33, - 34, - 42, - 52, - 24, - 62, - 22, - 62, - 2, - 34, - 63, - 68, - 42, - 363, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 24, - 62, - 34, - 34, - 33, - 42, - 56, - 55, - 26, - 24, - 62, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 55, - 24, - 9, - 62, - 62, - 34, - 33, - 34, - 37, - 42, - 56, - 24, - 167, - 9, - 26, - 62, - 26, - 33, - 42, - 56, - 57, - 24, - 62, - 62, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 9, - 24, - 33, - 34, - 34, - 34, - 42, - 56, - 57, - 26, - 34, - 34, - 37, - 56, - 57, - 62, - 24, - 33, - 34, - 34, - 34, - 502, - 55, - 62, - 24, - 33, - 34, - 42, - 56, - 57, - 24, - 34, - 34, - 37, - 56, - 52, - 24, - 26, - 33, - 34, - 34, - 37, - 42, - 56, - 62, - 24, - 24, - 34, - 34, - 33, - 37, - 42, - 56, - 55, - 24, - 9, - 24, - 24, - 26, - 24, - 34, - 34, - 37, - 42, - 363, - 24, - 24, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 26, - 24, - 34, - 33, - 34, - 42, - 56, - 55, - 62, - 24, - 62, - 34, - 34, - 63, - 42, - 56, - 55, - 24, - 2, - 9, - 34, - 63, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 34, - 34, - 34, - 37, - 42, - 52, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 62, - 34, - 34, - 34, - 37, - 56, - 245, - 62, - 24, - 62, - 34, - 34, - 34, - 333, - 56, - 57, - 26, - 24, - 34, - 34, - 63, - 42, - 45, - 363, - 24, - 26, - 33, - 33, - 33, - 34, - 37, - 42, - 56, - 24, - 24, - 62, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 22, - 24, - 33, - 42, - 56, - 57, - 24, - 71, - 33, - 34, - 34, - 33, - 42, - 60, - 24, - 62, - 33, - 68, - 56, - 57, - 2, - 34, - 34, - 34, - 37, - 333, - 363, - 24, - 24, - 24, - 34, - 33, - 34, - 37, - 42, - 57, - 34, - 34, - 24, - 56, - 363, - 24, - 62, - 24, - 34, - 37, - 52, - 62, - 63, - 33, - 42, - 55, - 24, - 33, - 33, - 42, - 55, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 2, - 2, - 26, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 2, - 24, - 34, - 34, - 33, - 37, - 42, - 55, - 24, - 26, - 34, - 34, - 24, - 42, - 56, - 24, - 24, - 71, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 23, - 26, - 62, - 26, - 62, - 34, - 34, - 34, - 68, - 42, - 55, - 9, - 62, - 63, - 63, - 34, - 34, - 37, - 42, - 55, - 24, - 29, - 24, - 34, - 34, - 34, - 68, - 42, - 42, - 55, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 363, - 24, - 62, - 34, - 34, - 33, - 34, - 42, - 55, - 62, - 23, - 24, - 34, - 33, - 34, - 42, - 56, - 60, - 62, - 9, - 34, - 34, - 63, - 33, - 42, - 42, - 363, - 24, - 9, - 62, - 62, - 61, - 33, - 34, - 34, - 42, - 56, - 57, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 24, - 62, - 34, - 33, - 33, - 37, - 42, - 55, - 62, - 34, - 63, - 34, - 37, - 42, - 56, - 9, - 2, - 9, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 24, - 62, - 33, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 62, - 63, - 2, - 34, - 42, - 56, - 55, - 24, - 26, - 62, - 24, - 34, - 34, - 42, - 56, - 55, - 57, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 357, - 62, - 24, - 34, - 33, - 33, - 42, - 56, - 55, - 24, - 62, - 34, - 34, - 63, - 36, - 333, - 56, - 57, - 65, - 24, - 24, - 24, - 24, - 26, - 62, - 34, - 34, - 33, - 37, - 333, - 56, - 55, - 24, - 22, - 24, - 33, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 34, - 34, - 34, - 34, - 42, - 42, - 60, - 24, - 62, - 24, - 24, - 26, - 34, - 34, - 24, - 42, - 56, - 55, - 24, - 26, - 34, - 34, - 33, - 34, - 42, - 363, - 62, - 313, - 24, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 22, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 2, - 2, - 9, - 62, - 24, - 34, - 33, - 34, - 333, - 42, - 49, - 57, - 22, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 245, - 62, - 62, - 34, - 34, - 34, - 42, - 45, - 55, - 24, - 26, - 62, - 24, - 26, - 63, - 34, - 33, - 33, - 42, - 56, - 363, - 24, - 26, - 24, - 34, - 34, - 34, - 34, - 37, - 56, - 57, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 42, - 363, - 9, - 34, - 34, - 63, - 34, - 42, - 56, - 52, - 57, - 62, - 34, - 34, - 34, - 34, - 2, - 42, - 56, - 55, - 62, - 357, - 26, - 62, - 63, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 24, - 24, - 34, - 34, - 34, - 2, - 42, - 56, - 57, - 65, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 63, - 34, - 34, - 36, - 42, - 55, - 24, - 62, - 71, - 34, - 34, - 34, - 68, - 333, - 56, - 55, - 62, - 29, - 34, - 33, - 34, - 42, - 56, - 55, - 62, - 26, - 24, - 34, - 33, - 34, - 33, - 42, - 56, - 55, - 24, - 26, - 34, - 33, - 34, - 33, - 42, - 42, - 55, - 24, - 81, - 503, - 9, - 9, - 24, - 62, - 26, - 62, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 9, - 24, - 63, - 34, - 63, - 68, - 42, - 56, - 55, - 62, - 62, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 2, - 26, - 24, - 62, - 62, - 63, - 33, - 34, - 37, - 42, - 56, - 57, - 62, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 60, - 57, - 24, - 24, - 34, - 34, - 34, - 34, - 42, - 42, - 363, - 23, - 26, - 34, - 34, - 34, - 33, - 42, - 42, - 56, - 57, - 2, - 62, - 34, - 24, - 33, - 34, - 42, - 56, - 363, - 62, - 26, - 34, - 34, - 34, - 33, - 68, - 42, - 363, - 24, - 62, - 26, - 24, - 34, - 34, - 33, - 37, - 42, - 34, - 34, - 33, - 37, - 56, - 62, - 22, - 62, - 24, - 34, - 33, - 36, - 56, - 57, - 26, - 24, - 34, - 34, - 24, - 56, - 57, - 34, - 34, - 34, - 37, - 42, - 56, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 2, - 2, - 9, - 34, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 24, - 9, - 34, - 33, - 34, - 37, - 56, - 57, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 26, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 504, - 24, - 2, - 34, - 34, - 34, - 42, - 56, - 55, - 9, - 24, - 62, - 34, - 34, - 34, - 34, - 42, - 40, - 363, - 24, - 62, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 56, - 55, - 24, - 26, - 24, - 34, - 34, - 33, - 34, - 42, - 42, - 60, - 24, - 26, - 62, - 62, - 33, - 37, - 42, - 56, - 57, - 22, - 34, - 34, - 26, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 34, - 63, - 34, - 33, - 42, - 56, - 57, - 505, - 2, - 178, - 509, - 510, - 511, - 9, - 24, - 33, - 33, - 34, - 333, - 56, - 55, - 62, - 9, - 24, - 34, - 63, - 63, - 42, - 56, - 55, - 24, - 9, - 24, - 62, - 33, - 34, - 34, - 42, - 56, - 55, - 2, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 62, - 24, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 22, - 24, - 34, - 34, - 2, - 37, - 42, - 56, - 57, - 24, - 26, - 62, - 33, - 33, - 34, - 68, - 42, - 56, - 55, - 22, - 24, - 33, - 33, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 57, - 24, - 34, - 34, - 63, - 37, - 56, - 245, - 24, - 9, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 62, - 34, - 34, - 34, - 42, - 42, - 55, - 24, - 24, - 24, - 26, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 62, - 62, - 62, - 62, - 63, - 33, - 34, - 42, - 42, - 60, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 2, - 9, - 22, - 24, - 34, - 33, - 34, - 33, - 42, - 42, - 241, - 57, - 512, - 24, - 33, - 34, - 24, - 42, - 56, - 62, - 24, - 26, - 24, - 33, - 33, - 34, - 37, - 42, - 56, - 55, - 9, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 22, - 24, - 24, - 26, - 34, - 34, - 34, - 24, - 42, - 61, - 55, - 24, - 9, - 62, - 63, - 34, - 34, - 68, - 56, - 55, - 24, - 22, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 62, - 26, - 34, - 34, - 55, - 357, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 245, - 24, - 9, - 2, - 9, - 24, - 34, - 34, - 63, - 68, - 42, - 56, - 60, - 24, - 62, - 34, - 63, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 23, - 62, - 34, - 34, - 34, - 34, - 34, - 42, - 42, - 56, - 55, - 2, - 24, - 34, - 34, - 56, - 55, - 26, - 34, - 34, - 37, - 42, - 40, - 62, - 26, - 34, - 34, - 33, - 68, - 333, - 56, - 56, - 57, - 24, - 65, - 62, - 33, - 34, - 34, - 68, - 42, - 56, - 55, - 57, - 24, - 26, - 31, - 31, - 26, - 62, - 24, - 33, - 37, - 42, - 56, - 57, - 24, - 33, - 37, - 37, - 42, - 42, - 56, - 57, - 24, - 65, - 34, - 42, - 56, - 52, - 57, - 24, - 62, - 34, - 57, - 26, - 34, - 34, - 63, - 34, - 42, - 56, - 55, - 24, - 24, - 24, - 9, - 65, - 24, - 71, - 63, - 34, - 34, - 502, - 42, - 56, - 24, - 24, - 24, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 9, - 9, - 2, - 24, - 24, - 34, - 34, - 34, - 34, - 34, - 42, - 56, - 52, - 57, - 22, - 33, - 34, - 42, - 56, - 62, - 514, - 24, - 62, - 22, - 62, - 34, - 34, - 34, - 33, - 42, - 42, - 56, - 55, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 9, - 62, - 34, - 34, - 34, - 33, - 68, - 42, - 56, - 52, - 57, - 24, - 26, - 24, - 33, - 34, - 33, - 34, - 63, - 42, - 56, - 55, - 24, - 26, - 33, - 34, - 34, - 42, - 57, - 62, - 24, - 33, - 34, - 34, - 68, - 42, - 42, - 56, - 55, - 24, - 26, - 33, - 33, - 34, - 42, - 56, - 57, - 9, - 24, - 34, - 33, - 34, - 68, - 42, - 363, - 62, - 24, - 2, - 24, - 34, - 34, - 34, - 68, - 42, - 44, - 361, - 57, - 24, - 22, - 24, - 22, - 24, - 42, - 52, - 62, - 9, - 24, - 34, - 33, - 63, - 42, - 42, - 55, - 24, - 2, - 62, - 63, - 34, - 34, - 333, - 56, - 57, - 24, - 71, - 33, - 34, - 63, - 37, - 56, - 55, - 24, - 24, - 22, - 24, - 24, - 24, - 34, - 34, - 34, - 34, - 333, - 56, - 55, - 24, - 24, - 34, - 369, - 34, - 42, - 56, - 56, - 24, - 30, - 26, - 62, - 24, - 24, - 34, - 63, - 34, - 34, - 42, - 333, - 56, - 55, - 9, - 62, - 33, - 63, - 63, - 34, - 68, - 42, - 56, - 55, - 62, - 24, - 62, - 34, - 34, - 34, - 36, - 42, - 56, - 363, - 57, - 26, - 24, - 33, - 63, - 34, - 24, - 56, - 60, - 24, - 24, - 24, - 24, - 34, - 33, - 34, - 33, - 37, - 42, - 56, - 55, - 62, - 26, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 26, - 62, - 34, - 34, - 34, - 37, - 56, - 363, - 24, - 2, - 62, - 34, - 61, - 472, - 219, - 42, - 34, - 42, - 42, - 26, - 57, - 9, - 55, - 62, - 42, - 62, - 34, - 34, - 24, - 9, - 9, - 9, - 9, - 10, - 62, - 24, - 2, - 34, - 37, - 42, - 56, - 57, - 2, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 24, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 52, - 57, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 34, - 34, - 63, - 62, - 60, - 61, - 61, - 34, - 34, - 34, - 9, - 37, - 57, - 34, - 57, - 62, - 34, - 2, - 56, - 65, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 42, - 60, - 24, - 34, - 34, - 34, - 63, - 42, - 56, - 57, - 24, - 34, - 34, - 34, - 37, - 42, - 26, - 34, - 63, - 37, - 56, - 24, - 71, - 24, - 24, - 33, - 34, - 34, - 42, - 56, - 57, - 524, - 33, - 34, - 34, - 42, - 56, - 55, - 26, - 24, - 34, - 33, - 34, - 24, - 42, - 55, - 24, - 24, - 34, - 33, - 34, - 42, - 42, - 56, - 57, - 24, - 26, - 71, - 24, - 34, - 34, - 34, - 42, - 42, - 34, - 34, - 33, - 37, - 56, - 57, - 9, - 71, - 33, - 34, - 34, - 37, - 56, - 62, - 24, - 2, - 24, - 33, - 34, - 33, - 36, - 42, - 55, - 26, - 34, - 34, - 34, - 37, - 42, - 52, - 24, - 24, - 9, - 62, - 63, - 34, - 34, - 42, - 56, - 55, - 26, - 62, - 34, - 34, - 34, - 2, - 37, - 42, - 55, - 65, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 26, - 24, - 34, - 34, - 68, - 42, - 52, - 24, - 71, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 9, - 34, - 33, - 34, - 34, - 42, - 56, - 24, - 26, - 34, - 34, - 63, - 42, - 56, - 55, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 140, - 139, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 169, - 169, - 142, - 142, - 142, - 142, - 3, - 3, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 4, - 6, - 7, - 5, - 7, - 3, - 5, - 6, - 7, - 6, - 6, - 6, - 6, - 5, - 7, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 7, - 6, - 6, - 6, - 6, - 6, - 7, - 5, - 5, - 5, - 5, - 5, - 170, - 5, - 5, - 4, - 5, - 7, - 5, - 5, - 5, - 5, - 7, - 6, - 6, - 7, - 5, - 5, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 4, - 6, - 6, - 5, - 5, - 4, - 5, - 3, - 5, - 5, - 5, - 7, - 2, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 3, - 6, - 6, - 7, - 5, - 7, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 8, - 8, - 8, - 9, - 62, - 34, - 34, - 34, - 42, - 55, - 24, - 26, - 24, - 34, - 34, - 34, - 34, - 23, - 42, - 55, - 24, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 33, - 33, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 37, - 42, - 56, - 24, - 24, - 63, - 34, - 34, - 37, - 42, - 56, - 24, - 26, - 33, - 33, - 34, - 37, - 333, - 24, - 34, - 34, - 34, - 36, - 42, - 55, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 62, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 24, - 34, - 34, - 37, - 42, - 55, - 24, - 71, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 71, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 65, - 62, - 62, - 34, - 34, - 33, - 37, - 42, - 60, - 62, - 71, - 34, - 34, - 34, - 24, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 37, - 56, - 363, - 24, - 26, - 34, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 31, - 26, - 63, - 34, - 34, - 37, - 42, - 56, - 62, - 24, - 22, - 34, - 34, - 34, - 63, - 42, - 56, - 57, - 62, - 9, - 2, - 9, - 2, - 9, - 26, - 34, - 34, - 34, - 37, - 56, - 57, - 34, - 34, - 63, - 34, - 37, - 42, - 52, - 2, - 71, - 24, - 34, - 33, - 63, - 37, - 42, - 60, - 62, - 26, - 24, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 9, - 24, - 24, - 22, - 62, - 34, - 34, - 34, - 33, - 42, - 243, - 52, - 24, - 26, - 24, - 34, - 34, - 33, - 34, - 37, - 56, - 55, - 65, - 62, - 34, - 34, - 34, - 38, - 525, - 363, - 62, - 357, - 62, - 24, - 33, - 34, - 34, - 34, - 42, - 56, - 55, - 500, - 23, - 34, - 34, - 33, - 42, - 42, - 55, - 24, - 62, - 24, - 24, - 2, - 24, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 63, - 34, - 42, - 56, - 55, - 65, - 62, - 24, - 34, - 34, - 34, - 37, - 56, - 55, - 24, - 65, - 24, - 24, - 33, - 34, - 34, - 36, - 42, - 52, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 57, - 62, - 65, - 62, - 33, - 34, - 34, - 38, - 42, - 55, - 24, - 26, - 33, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 9, - 9, - 9, - 24, - 33, - 34, - 34, - 37, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 2, - 56, - 57, - 26, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 24, - 33, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 24, - 34, - 34, - 33, - 36, - 42, - 527, - 62, - 24, - 62, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 71, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 62, - 24, - 34, - 34, - 34, - 42, - 42, - 55, - 62, - 26, - 34, - 33, - 24, - 24, - 42, - 56, - 24, - 62, - 26, - 62, - 31, - 9, - 62, - 23, - 62, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 62, - 24, - 24, - 71, - 62, - 34, - 34, - 37, - 42, - 56, - 363, - 62, - 65, - 24, - 34, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 24, - 26, - 34, - 63, - 34, - 34, - 42, - 56, - 55, - 24, - 357, - 9, - 2, - 235, - 528, - 306, - 533, - 71, - 24, - 24, - 63, - 34, - 33, - 37, - 42, - 363, - 9, - 24, - 62, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 24, - 26, - 24, - 34, - 34, - 42, - 56, - 24, - 71, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 26, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 57, - 2, - 62, - 34, - 34, - 34, - 42, - 56, - 57, - 65, - 34, - 33, - 34, - 37, - 56, - 55, - 24, - 26, - 34, - 34, - 34, - 63, - 42, - 56, - 52, - 24, - 62, - 24, - 34, - 68, - 42, - 56, - 62, - 62, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 26, - 24, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 2, - 62, - 62, - 34, - 63, - 34, - 37, - 42, - 56, - 55, - 65, - 62, - 63, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 63, - 34, - 33, - 34, - 42, - 56, - 57, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 81, - 537, - 98, - 543, - 2, - 124, - 26, - 24, - 63, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 34, - 34, - 33, - 34, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 34, - 63, - 37, - 42, - 56, - 62, - 62, - 24, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 55, - 26, - 33, - 33, - 34, - 33, - 42, - 56, - 55, - 62, - 65, - 24, - 24, - 34, - 63, - 34, - 34, - 37, - 42, - 55, - 2, - 24, - 33, - 34, - 34, - 37, - 56, - 55, - 24, - 26, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 9, - 24, - 33, - 34, - 34, - 68, - 42, - 56, - 55, - 62, - 9, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 57, - 62, - 22, - 24, - 33, - 63, - 34, - 37, - 42, - 56, - 24, - 71, - 34, - 34, - 34, - 68, - 42, - 56, - 62, - 62, - 34, - 33, - 34, - 33, - 42, - 40, - 55, - 62, - 62, - 71, - 31, - 63, - 33, - 34, - 36, - 42, - 56, - 57, - 71, - 62, - 2, - 24, - 63, - 34, - 33, - 37, - 42, - 55, - 62, - 9, - 9, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 71, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 33, - 34, - 68, - 42, - 56, - 57, - 24, - 26, - 24, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 62, - 71, - 24, - 22, - 24, - 63, - 34, - 33, - 34, - 42, - 42, - 56, - 55, - 24, - 26, - 62, - 34, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 63, - 42, - 55, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 60, - 57, - 24, - 65, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 57, - 24, - 9, - 24, - 34, - 34, - 34, - 42, - 42, - 60, - 57, - 24, - 24, - 2, - 9, - 34, - 34, - 34, - 34, - 42, - 42, - 60, - 24, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 9, - 24, - 24, - 34, - 34, - 68, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 34, - 34, - 390, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 24, - 71, - 63, - 34, - 33, - 42, - 56, - 55, - 62, - 62, - 65, - 34, - 34, - 33, - 37, - 42, - 363, - 62, - 31, - 26, - 62, - 34, - 34, - 34, - 42, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 55, - 24, - 26, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 2, - 2, - 2, - 2, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 169, - 140, - 140, - 3, - 3, - 5, - 6, - 5, - 61, - 61, - 61, - 6, - 5, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 3, - 7, - 6, - 4, - 6, - 7, - 6, - 7, - 5, - 5, - 6, - 5, - 171, - 42, - 42, - 9, - 33, - 34, - 42, - 42, - 55, - 24, - 62, - 34, - 34, - 42, - 56, - 512, - 71, - 24, - 34, - 33, - 68, - 42, - 56, - 57, - 22, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 55, - 9, - 24, - 34, - 34, - 34, - 42, - 42, - 60, - 62, - 9, - 71, - 34, - 9, - 57, - 65, - 24, - 24, - 34, - 33, - 33, - 42, - 56, - 55, - 62, - 24, - 33, - 34, - 33, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 34, - 61, - 61, - 61, - 61, - 61, - 26, - 34, - 37, - 56, - 65, - 34, - 42, - 56, - 9, - 42, - 56, - 37, - 62, - 34, - 24, - 26, - 24, - 57, - 34, - 34, - 42, - 544, - 26, - 34, - 42, - 56, - 363, - 33, - 34, - 42, - 65, - 33, - 42, - 377, - 34, - 33, - 37, - 24, - 34, - 34, - 363, - 9, - 9, - 34, - 62, - 24, - 37, - 42, - 56, - 26, - 62, - 33, - 33, - 37, - 56, - 55, - 24, - 26, - 62, - 33, - 34, - 34, - 37, - 55, - 62, - 34, - 34, - 34, - 37, - 55, - 24, - 26, - 62, - 22, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 34, - 33, - 33, - 37, - 56, - 60, - 62, - 62, - 71, - 24, - 2, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 71, - 62, - 34, - 34, - 34, - 34, - 42, - 44, - 55, - 22, - 24, - 24, - 62, - 24, - 62, - 26, - 62, - 34, - 33, - 34, - 37, - 42, - 60, - 57, - 26, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 24, - 26, - 24, - 33, - 34, - 37, - 42, - 56, - 24, - 24, - 33, - 34, - 37, - 56, - 245, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 33, - 63, - 33, - 333, - 56, - 357, - 62, - 34, - 33, - 34, - 34, - 42, - 56, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 36, - 42, - 56, - 57, - 24, - 34, - 34, - 33, - 33, - 42, - 56, - 55, - 24, - 65, - 33, - 34, - 34, - 37, - 42, - 56, - 31, - 62, - 62, - 34, - 34, - 34, - 37, - 42, - 245, - 62, - 26, - 33, - 34, - 33, - 68, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 2, - 24, - 33, - 34, - 34, - 42, - 56, - 52, - 24, - 24, - 26, - 26, - 33, - 63, - 34, - 42, - 56, - 55, - 24, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 363, - 62, - 62, - 62, - 23, - 34, - 34, - 34, - 42, - 56, - 60, - 26, - 24, - 34, - 33, - 34, - 34, - 42, - 56, - 245, - 57, - 33, - 34, - 34, - 37, - 42, - 55, - 24, - 24, - 34, - 34, - 63, - 34, - 42, - 245, - 62, - 545, - 9, - 18, - 62, - 62, - 33, - 34, - 34, - 37, - 42, - 52, - 57, - 24, - 26, - 34, - 34, - 63, - 390, - 42, - 55, - 62, - 2, - 62, - 33, - 34, - 34, - 37, - 42, - 52, - 24, - 26, - 33, - 34, - 34, - 42, - 56, - 55, - 24, - 62, - 34, - 34, - 34, - 2, - 42, - 56, - 57, - 62, - 34, - 63, - 33, - 37, - 42, - 55, - 24, - 63, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 62, - 34, - 34, - 33, - 42, - 56, - 57, - 26, - 34, - 63, - 33, - 37, - 42, - 55, - 24, - 24, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 26, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 62, - 62, - 63, - 34, - 34, - 34, - 42, - 310, - 245, - 62, - 62, - 26, - 63, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 24, - 61, - 24, - 24, - 24, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 9, - 24, - 34, - 63, - 37, - 333, - 56, - 55, - 23, - 62, - 33, - 34, - 33, - 37, - 42, - 56, - 55, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 332, - 111, - 9, - 9, - 9, - 9, - 29, - 62, - 33, - 34, - 56, - 55, - 9, - 56, - 57, - 62, - 22, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 57, - 9, - 62, - 34, - 34, - 34, - 42, - 56, - 24, - 24, - 24, - 34, - 33, - 34, - 37, - 56, - 24, - 34, - 34, - 34, - 42, - 56, - 24, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 313, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 33, - 34, - 34, - 68, - 42, - 52, - 24, - 26, - 34, - 34, - 33, - 37, - 42, - 55, - 24, - 26, - 34, - 34, - 33, - 34, - 42, - 52, - 62, - 24, - 26, - 34, - 34, - 33, - 42, - 42, - 55, - 24, - 22, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 62, - 24, - 33, - 37, - 42, - 56, - 55, - 24, - 311, - 24, - 62, - 34, - 33, - 34, - 36, - 42, - 56, - 57, - 9, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 34, - 63, - 34, - 36, - 42, - 57, - 26, - 62, - 34, - 33, - 34, - 37, - 56, - 57, - 9, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 26, - 34, - 33, - 34, - 33, - 42, - 56, - 57, - 62, - 65, - 24, - 34, - 63, - 34, - 33, - 42, - 56, - 55, - 23, - 2, - 63, - 34, - 34, - 34, - 42, - 42, - 55, - 62, - 24, - 2, - 26, - 62, - 34, - 33, - 34, - 37, - 42, - 52, - 24, - 62, - 24, - 9, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 525, - 363, - 9, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 33, - 33, - 34, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 33, - 37, - 42, - 52, - 57, - 62, - 9, - 24, - 34, - 34, - 33, - 42, - 56, - 60, - 62, - 2, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 24, - 62, - 24, - 34, - 34, - 34, - 57, - 24, - 65, - 62, - 33, - 34, - 34, - 34, - 42, - 40, - 55, - 62, - 2, - 24, - 34, - 34, - 33, - 37, - 42, - 56, - 49, - 24, - 377, - 24, - 34, - 34, - 33, - 63, - 37, - 42, - 56, - 57, - 9, - 26, - 24, - 62, - 33, - 24, - 33, - 42, - 42, - 55, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 55, - 62, - 62, - 26, - 24, - 34, - 34, - 63, - 33, - 42, - 56, - 55, - 62, - 26, - 34, - 33, - 34, - 34, - 68, - 42, - 52, - 24, - 62, - 34, - 34, - 37, - 42, - 57, - 23, - 34, - 33, - 34, - 42, - 56, - 9, - 34, - 34, - 63, - 63, - 37, - 42, - 56, - 62, - 62, - 24, - 24, - 2, - 24, - 34, - 33, - 36, - 42, - 42, - 55, - 24, - 22, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 22, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 71, - 34, - 33, - 34, - 34, - 42, - 56, - 57, - 62, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 24, - 34, - 33, - 33, - 37, - 42, - 56, - 55, - 26, - 24, - 33, - 34, - 34, - 34, - 42, - 56, - 62, - 26, - 24, - 63, - 34, - 34, - 34, - 42, - 42, - 363, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 141, - 140, - 140, - 169, - 169, - 139, - 139, - 140, - 139, - 169, - 139, - 139, - 140, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 142, - 142, - 142, - 2, - 2, - 2, - 3, - 3, - 7, - 24, - 26, - 34, - 61, - 62, - 9, - 34, - 24, - 34, - 24, - 34, - 34, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 71, - 63, - 34, - 68, - 42, - 9, - 26, - 34, - 34, - 34, - 37, - 42, - 57, - 24, - 62, - 34, - 34, - 34, - 37, - 56, - 55, - 26, - 24, - 34, - 33, - 34, - 36, - 42, - 55, - 24, - 26, - 63, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 22, - 24, - 24, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 57, - 2, - 62, - 24, - 34, - 33, - 37, - 56, - 55, - 24, - 34, - 63, - 42, - 56, - 62, - 9, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 62, - 62, - 34, - 33, - 33, - 56, - 55, - 62, - 62, - 34, - 34, - 37, - 42, - 55, - 9, - 34, - 33, - 34, - 68, - 42, - 363, - 57, - 24, - 24, - 24, - 24, - 34, - 63, - 34, - 42, - 56, - 363, - 24, - 2, - 62, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 24, - 24, - 34, - 33, - 34, - 37, - 56, - 57, - 62, - 62, - 24, - 63, - 34, - 34, - 37, - 42, - 56, - 57, - 23, - 26, - 24, - 33, - 33, - 33, - 37, - 42, - 56, - 62, - 9, - 24, - 62, - 34, - 34, - 34, - 502, - 56, - 57, - 26, - 62, - 63, - 34, - 33, - 37, - 56, - 57, - 24, - 63, - 34, - 33, - 37, - 42, - 52, - 24, - 62, - 26, - 62, - 33, - 34, - 34, - 42, - 56, - 57, - 24, - 33, - 68, - 42, - 52, - 24, - 26, - 62, - 33, - 34, - 37, - 42, - 2, - 33, - 33, - 33, - 34, - 42, - 55, - 24, - 34, - 34, - 42, - 56, - 57, - 26, - 34, - 34, - 34, - 68, - 56, - 24, - 24, - 24, - 34, - 34, - 63, - 34, - 42, - 56, - 24, - 9, - 24, - 34, - 34, - 63, - 34, - 68, - 42, - 52, - 62, - 22, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 34, - 34, - 34, - 33, - 42, - 56, - 57, - 2, - 34, - 34, - 34, - 34, - 56, - 55, - 24, - 24, - 71, - 62, - 34, - 34, - 37, - 42, - 56, - 55, - 26, - 34, - 63, - 33, - 34, - 42, - 56, - 55, - 24, - 24, - 2, - 24, - 33, - 34, - 42, - 56, - 363, - 34, - 33, - 37, - 42, - 363, - 24, - 378, - 9, - 24, - 34, - 34, - 63, - 55, - 62, - 34, - 33, - 34, - 42, - 56, - 9, - 24, - 34, - 33, - 63, - 42, - 56, - 55, - 24, - 24, - 33, - 34, - 33, - 42, - 56, - 55, - 24, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 24, - 62, - 34, - 37, - 42, - 57, - 26, - 34, - 34, - 34, - 37, - 56, - 57, - 33, - 34, - 33, - 42, - 55, - 24, - 34, - 33, - 33, - 42, - 52, - 24, - 24, - 34, - 34, - 42, - 56, - 55, - 24, - 34, - 34, - 34, - 34, - 37, - 42, - 52, - 62, - 22, - 24, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 62, - 34, - 63, - 34, - 42, - 42, - 55, - 62, - 9, - 24, - 62, - 24, - 34, - 33, - 33, - 42, - 56, - 55, - 62, - 9, - 62, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 33, - 34, - 34, - 390, - 56, - 55, - 62, - 2, - 113, - 9, - 2, - 26, - 24, - 62, - 63, - 34, - 37, - 42, - 546, - 62, - 34, - 34, - 37, - 56, - 55, - 24, - 9, - 34, - 34, - 63, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 37, - 42, - 57, - 62, - 2, - 34, - 33, - 333, - 24, - 62, - 34, - 34, - 63, - 42, - 60, - 414, - 31, - 33, - 57, - 33, - 33, - 34, - 37, - 42, - 56, - 57, - 26, - 2, - 63, - 34, - 68, - 42, - 55, - 26, - 62, - 63, - 34, - 33, - 34, - 37, - 42, - 52, - 57, - 2, - 24, - 34, - 34, - 63, - 42, - 42, - 55, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 31, - 34, - 34, - 37, - 42, - 60, - 62, - 26, - 63, - 63, - 63, - 36, - 56, - 363, - 24, - 24, - 26, - 63, - 33, - 34, - 37, - 56, - 55, - 24, - 22, - 24, - 34, - 63, - 34, - 42, - 56, - 9, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 34, - 34, - 68, - 42, - 55, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 378, - 9, - 9, - 2, - 548, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 34, - 34, - 34, - 37, - 56, - 55, - 62, - 24, - 9, - 34, - 34, - 34, - 37, - 42, - 57, - 62, - 34, - 63, - 37, - 42, - 55, - 2, - 24, - 62, - 33, - 33, - 24, - 33, - 42, - 56, - 57, - 26, - 33, - 19, - 24, - 34, - 33, - 63, - 37, - 42, - 56, - 57, - 65, - 24, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 63, - 42, - 60, - 24, - 2, - 62, - 34, - 33, - 34, - 42, - 56, - 55, - 549, - 24, - 62, - 34, - 33, - 42, - 42, - 60, - 62, - 26, - 24, - 33, - 34, - 33, - 42, - 56, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 62, - 62, - 34, - 34, - 34, - 34, - 42, - 42, - 52, - 57, - 406, - 62, - 24, - 24, - 26, - 62, - 34, - 33, - 34, - 37, - 42, - 55, - 9, - 100, - 366, - 9, - 24, - 62, - 22, - 24, - 34, - 33, - 34, - 63, - 42, - 52, - 57, - 24, - 26, - 62, - 33, - 33, - 37, - 42, - 56, - 57, - 26, - 34, - 34, - 34, - 37, - 56, - 52, - 24, - 62, - 33, - 33, - 68, - 42, - 55, - 9, - 62, - 33, - 63, - 37, - 42, - 56, - 57, - 62, - 24, - 62, - 34, - 34, - 37, - 42, - 55, - 62, - 26, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 71, - 24, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 62, - 63, - 34, - 34, - 37, - 42, - 42, - 363, - 9, - 62, - 34, - 34, - 34, - 42, - 42, - 363, - 24, - 9, - 62, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 34, - 34, - 34, - 42, - 56, - 363, - 62, - 33, - 34, - 63, - 37, - 42, - 55, - 26, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 550, - 111, - 232, - 113, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 9, - 140, - 139, - 139, - 169, - 169, - 140, - 140, - 140, - 139, - 169, - 169, - 169, - 169, - 169, - 140, - 139, - 140, - 140, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 6, - 3, - 5, - 4, - 5, - 4, - 6, - 7, - 6, - 5, - 7, - 5, - 6, - 6, - 5, - 5, - 7, - 7, - 5, - 5, - 5, - 5, - 3, - 5, - 2, - 5, - 7, - 7, - 5, - 5, - 6, - 5, - 3, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 5, - 5, - 4, - 5, - 7, - 6, - 7, - 5, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 6, - 5, - 7, - 7, - 5, - 7, - 7, - 6, - 5, - 6, - 6, - 5, - 7, - 5, - 6, - 6, - 6, - 4, - 5, - 5, - 5, - 5, - 4, - 5, - 5, - 6, - 6, - 6, - 5, - 6, - 5, - 7, - 6, - 6, - 2, - 5, - 5, - 6, - 5, - 6, - 7, - 7, - 5, - 5, - 5, - 6, - 7, - 6, - 2, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 7, - 6, - 5, - 5, - 6, - 7, - 5, - 5, - 4, - 7, - 6, - 7, - 6, - 6, - 4, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 6, - 8, - 8, - 8, - 8, - 8, - 2, - 9, - 10, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 62, - 24, - 34, - 34, - 37, - 42, - 55, - 23, - 9, - 24, - 24, - 34, - 34, - 42, - 527, - 357, - 23, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 42, - 55, - 24, - 62, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 9, - 62, - 34, - 34, - 33, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 18, - 111, - 388, - 9, - 2, - 9, - 9, - 9, - 9, - 2, - 2, - 138, - 135, - 142, - 3, - 7, - 61, - 61, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 140, - 169, - 140, - 169, - 139, - 169, - 139, - 139, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 3, - 5, - 6, - 6, - 6, - 5, - 8, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 363, - 57, - 24, - 61, - 10, - 10, - 10, - 34, - 37, - 42, - 56, - 57, - 551, - 357, - 24, - 33, - 42, - 57, - 24, - 34, - 42, - 42, - 363, - 57, - 24, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 406, - 24, - 62, - 22, - 63, - 34, - 34, - 37, - 56, - 60, - 62, - 19, - 24, - 24, - 34, - 33, - 42, - 56, - 57, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 9, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 141, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 140, - 139, - 140, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 142, - 142, - 142, - 142, - 2, - 2, - 3, - 5, - 5, - 7, - 4, - 3, - 5, - 6, - 5, - 7, - 7, - 5, - 5, - 5, - 7, - 5, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 170, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 6, - 3, - 3, - 4, - 7, - 7, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 7, - 5, - 6, - 6, - 6, - 5, - 5, - 7, - 6, - 6, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 6, - 7, - 6, - 6, - 5, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 4, - 2, - 6, - 6, - 4, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 170, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 4, - 5, - 5, - 7, - 6, - 4, - 7, - 6, - 5, - 6, - 7, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 6, - 3, - 4, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 4, - 5, - 5, - 8, - 8, - 8, - 8, - 2, - 9, - 9, - 553, - 195, - 213, - 510, - 9, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 34, - 3, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 7, - 33, - 26, - 63, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 33, - 37, - 42, - 56, - 55, - 24, - 9, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 377, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 2, - 24, - 554, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 167, - 139, - 169, - 140, - 169, - 140, - 140, - 169, - 140, - 169, - 169, - 169, - 139, - 140, - 169, - 169, - 139, - 139, - 140, - 140, - 139, - 140, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 3, - 7, - 6, - 5, - 4, - 7, - 5, - 6, - 5, - 5, - 5, - 6, - 4, - 4, - 5, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 5, - 7, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 3, - 5, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 7, - 7, - 61, - 6, - 6, - 5, - 5, - 5, - 6, - 2, - 6, - 6, - 6, - 5, - 5, - 7, - 5, - 5, - 4, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 5, - 7, - 5, - 5, - 5, - 3, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 7, - 7, - 5, - 5, - 6, - 6, - 2, - 5, - 4, - 7, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 7, - 6, - 7, - 5, - 5, - 4, - 4, - 6, - 6, - 7, - 6, - 6, - 3, - 5, - 7, - 6, - 6, - 5, - 7, - 6, - 5, - 7, - 7, - 7, - 5, - 5, - 8, - 8, - 354, - 9, - 9, - 2, - 471, - 409, - 160, - 162, - 555, - 2, - 556, - 227, - 229, - 557, - 226, - 306, - 558, - 24, - 62, - 26, - 24, - 34, - 33, - 33, - 37, - 42, - 55, - 62, - 24, - 24, - 34, - 33, - 33, - 42, - 42, - 55, - 62, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 71, - 62, - 33, - 34, - 34, - 37, - 42, - 55, - 26, - 37, - 34, - 42, - 34, - 42, - 57, - 62, - 63, - 42, - 55, - 71, - 33, - 56, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 400, - 9, - 34, - 56, - 62, - 26, - 34, - 34, - 37, - 42, - 55, - 2, - 24, - 34, - 42, - 56, - 57, - 26, - 24, - 34, - 34, - 26, - 34, - 34, - 42, - 24, - 24, - 34, - 42, - 55, - 34, - 34, - 42, - 56, - 24, - 24, - 33, - 33, - 333, - 24, - 24, - 33, - 34, - 56, - 62, - 34, - 34, - 56, - 24, - 33, - 34, - 34, - 42, - 57, - 9, - 34, - 34, - 26, - 33, - 37, - 52, - 62, - 26, - 24, - 33, - 34, - 42, - 57, - 24, - 24, - 63, - 34, - 37, - 55, - 26, - 34, - 34, - 34, - 68, - 56, - 62, - 26, - 34, - 56, - 55, - 26, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 33, - 42, - 56, - 57, - 26, - 26, - 63, - 34, - 63, - 37, - 56, - 57, - 23, - 62, - 34, - 33, - 56, - 55, - 554, - 9, - 34, - 33, - 37, - 56, - 24, - 34, - 42, - 56, - 62, - 71, - 357, - 34, - 33, - 42, - 43, - 34, - 363, - 9, - 26, - 24, - 34, - 37, - 55, - 22, - 24, - 26, - 62, - 34, - 34, - 56, - 57, - 34, - 34, - 33, - 42, - 56, - 55, - 24, - 62, - 34, - 37, - 56, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 363, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 113, - 367, - 9, - 24, - 34, - 37, - 42, - 57, - 24, - 33, - 34, - 37, - 56, - 26, - 34, - 34, - 42, - 57, - 24, - 33, - 60, - 313, - 34, - 56, - 24, - 2, - 63, - 63, - 42, - 62, - 34, - 34, - 37, - 33, - 42, - 313, - 33, - 34, - 56, - 62, - 24, - 34, - 37, - 55, - 26, - 34, - 34, - 42, - 56, - 55, - 62, - 33, - 63, - 34, - 37, - 42, - 55, - 24, - 34, - 34, - 34, - 37, - 56, - 57, - 62, - 33, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 24, - 71, - 34, - 34, - 33, - 37, - 42, - 56, - 52, - 24, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 57, - 62, - 26, - 24, - 24, - 24, - 34, - 34, - 42, - 42, - 55, - 26, - 34, - 34, - 42, - 56, - 57, - 62, - 33, - 34, - 33, - 37, - 42, - 55, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 405, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 142, - 142, - 142, - 2, - 3, - 2, - 3, - 4, - 6, - 6, - 6, - 6, - 5, - 4, - 6, - 5, - 7, - 6, - 7, - 5, - 6, - 6, - 7, - 6, - 6, - 4, - 6, - 5, - 5, - 6, - 6, - 6, - 170, - 5, - 6, - 5, - 5, - 6, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 4, - 7, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 6, - 6, - 5, - 7, - 5, - 4, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 7, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 4, - 7, - 6, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 7, - 6, - 5, - 7, - 5, - 6, - 6, - 6, - 7, - 5, - 5, - 5, - 6, - 5, - 4, - 5, - 6, - 7, - 5, - 3, - 5, - 5, - 5, - 6, - 5, - 4, - 5, - 4, - 5, - 7, - 5, - 5, - 6, - 5, - 5, - 8, - 8, - 8, - 8, - 9, - 2, - 24, - 63, - 33, - 33, - 42, - 56, - 55, - 62, - 327, - 24, - 33, - 34, - 33, - 68, - 56, - 55, - 24, - 26, - 34, - 33, - 33, - 24, - 42, - 55, - 62, - 24, - 65, - 71, - 34, - 63, - 34, - 68, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 48, - 55, - 24, - 34, - 34, - 33, - 68, - 42, - 42, - 55, - 9, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 62, - 34, - 34, - 34, - 37, - 55, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 26, - 33, - 34, - 34, - 37, - 42, - 34, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 3, - 3, - 3, - 5, - 5, - 7, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 7, - 6, - 5, - 2, - 6, - 6, - 6, - 5, - 24, - 34, - 42, - 62, - 34, - 37, - 62, - 26, - 34, - 34, - 34, - 40, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 57, - 24, - 65, - 24, - 34, - 37, - 42, - 56, - 55, - 62, - 62, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 34, - 9, - 62, - 34, - 42, - 56, - 57, - 62, - 71, - 24, - 33, - 34, - 34, - 42, - 55, - 34, - 63, - 37, - 42, - 363, - 24, - 2, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 62, - 62, - 26, - 24, - 24, - 34, - 63, - 33, - 37, - 42, - 52, - 57, - 26, - 34, - 34, - 34, - 68, - 42, - 56, - 24, - 62, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 71, - 24, - 24, - 63, - 34, - 33, - 42, - 56, - 55, - 9, - 24, - 63, - 34, - 34, - 34, - 37, - 42, - 55, - 57, - 71, - 24, - 34, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 26, - 62, - 63, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 57, - 26, - 63, - 63, - 34, - 33, - 37, - 42, - 56, - 57, - 62, - 65, - 33, - 33, - 34, - 37, - 42, - 56, - 55, - 24, - 550, - 9, - 62, - 24, - 65, - 34, - 34, - 34, - 37, - 42, - 52, - 57, - 24, - 9, - 24, - 24, - 33, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 559, - 55, - 24, - 65, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 65, - 62, - 24, - 10, - 24, - 62, - 71, - 62, - 33, - 34, - 33, - 34, - 42, - 56, - 57, - 24, - 22, - 34, - 34, - 34, - 34, - 333, - 56, - 57, - 24, - 9, - 113, - 560, - 26, - 63, - 34, - 33, - 34, - 42, - 56, - 55, - 57, - 24, - 22, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 24, - 34, - 34, - 34, - 36, - 42, - 55, - 24, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 2, - 34, - 34, - 34, - 34, - 37, - 42, - 55, - 24, - 9, - 24, - 34, - 34, - 68, - 42, - 56, - 57, - 24, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 33, - 33, - 42, - 56, - 55, - 24, - 65, - 65, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 357, - 71, - 34, - 34, - 34, - 37, - 42, - 56, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 34, - 63, - 34, - 34, - 42, - 56, - 62, - 24, - 34, - 34, - 37, - 42, - 56, - 2, - 34, - 33, - 34, - 42, - 42, - 52, - 62, - 24, - 62, - 34, - 34, - 42, - 55, - 23, - 26, - 24, - 34, - 63, - 63, - 37, - 42, - 56, - 245, - 24, - 71, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 140, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 141, - 140, - 139, - 139, - 139, - 139, - 140, - 139, - 140, - 142, - 142, - 142, - 2, - 3, - 3, - 3, - 3, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 7, - 6, - 6, - 5, - 3, - 6, - 5, - 6, - 6, - 2, - 6, - 5, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 6, - 7, - 5, - 5, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 4, - 6, - 6, - 9, - 34, - 34, - 34, - 33, - 37, - 42, - 56, - 55, - 414, - 24, - 33, - 24, - 42, - 358, - 57, - 24, - 24, - 62, - 34, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 3, - 7, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 5, - 6, - 5, - 5, - 4, - 6, - 5, - 7, - 6, - 5, - 7, - 6, - 6, - 6, - 6, - 6, - 5, - 7, - 6, - 7, - 5, - 6, - 5, - 6, - 61, - 61, - 61, - 61, - 61, - 113, - 400, - 367, - 9, - 9, - 235, - 197, - 562, - 147, - 563, - 237, - 225, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 9, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 19, - 62, - 24, - 33, - 33, - 34, - 42, - 56, - 57, - 9, - 33, - 34, - 34, - 34, - 42, - 52, - 62, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 26, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 42, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 9, - 9, - 24, - 24, - 9, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 33, - 63, - 42, - 56, - 55, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 24, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 313, - 24, - 34, - 33, - 33, - 37, - 42, - 56, - 57, - 26, - 24, - 62, - 24, - 24, - 24, - 26, - 33, - 34, - 63, - 34, - 42, - 363, - 24, - 29, - 34, - 34, - 34, - 34, - 34, - 42, - 363, - 551, - 65, - 62, - 62, - 33, - 34, - 37, - 45, - 57, - 22, - 71, - 24, - 34, - 34, - 34, - 37, - 333, - 52, - 55, - 9, - 24, - 33, - 33, - 33, - 68, - 42, - 52, - 24, - 65, - 71, - 63, - 42, - 56, - 245, - 57, - 24, - 9, - 24, - 34, - 33, - 68, - 42, - 56, - 55, - 62, - 24, - 2, - 22, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 24, - 24, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 24, - 34, - 33, - 34, - 42, - 56, - 24, - 26, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 33, - 33, - 34, - 37, - 42, - 57, - 24, - 34, - 34, - 34, - 37, - 56, - 57, - 24, - 26, - 24, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 2, - 111, - 9, - 26, - 62, - 34, - 34, - 24, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 33, - 34, - 63, - 333, - 56, - 9, - 26, - 62, - 24, - 34, - 34, - 34, - 33, - 42, - 56, - 57, - 26, - 62, - 34, - 34, - 34, - 68, - 42, - 52, - 62, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 26, - 34, - 34, - 33, - 68, - 42, - 56, - 55, - 24, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 26, - 34, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 9, - 24, - 34, - 63, - 34, - 37, - 56, - 57, - 24, - 24, - 71, - 34, - 34, - 34, - 34, - 42, - 358, - 24, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 113, - 232, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 140, - 139, - 140, - 139, - 139, - 140, - 140, - 141, - 140, - 140, - 169, - 140, - 139, - 140, - 140, - 139, - 139, - 169, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 2, - 6, - 6, - 7, - 5, - 5, - 5, - 6, - 5, - 5, - 4, - 5, - 5, - 7, - 6, - 7, - 6, - 3, - 6, - 6, - 5, - 4, - 6, - 6, - 5, - 5, - 4, - 6, - 2, - 6, - 7, - 5, - 6, - 6, - 7, - 5, - 5, - 7, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 6, - 7, - 5, - 6, - 6, - 5, - 7, - 5, - 5, - 6, - 7, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 6, - 5, - 4, - 6, - 6, - 5, - 5, - 6, - 4, - 6, - 6, - 5, - 5, - 5, - 7, - 6, - 7, - 7, - 6, - 6, - 5, - 6, - 7, - 6, - 5, - 5, - 6, - 5, - 7, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 6, - 6, - 6, - 4, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 5, - 6, - 4, - 6, - 5, - 7, - 7, - 6, - 6, - 5, - 5, - 7, - 5, - 7, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 7, - 6, - 354, - 8, - 8, - 9, - 9, - 65, - 24, - 24, - 65, - 24, - 24, - 24, - 34, - 34, - 42, - 40, - 55, - 62, - 24, - 34, - 34, - 34, - 68, - 42, - 55, - 24, - 9, - 24, - 33, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 65, - 24, - 34, - 34, - 33, - 36, - 42, - 56, - 55, - 62, - 567, - 9, - 9, - 29, - 34, - 34, - 33, - 34, - 37, - 245, - 24, - 24, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 26, - 34, - 34, - 34, - 34, - 333, - 42, - 56, - 62, - 24, - 26, - 24, - 34, - 34, - 63, - 34, - 42, - 56, - 55, - 62, - 24, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 3, - 34, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 24, - 357, - 62, - 34, - 2, - 42, - 55, - 9, - 143, - 162, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 167, - 167, - 167, - 140, - 141, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 169, - 140, - 169, - 142, - 3, - 3, - 2, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 4, - 7, - 5, - 5, - 7, - 5, - 5, - 6, - 6, - 6, - 3, - 7, - 5, - 6, - 5, - 6, - 2, - 4, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 2, - 6, - 5, - 5, - 7, - 6, - 2, - 5, - 3, - 5, - 5, - 7, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 6, - 7, - 7, - 5, - 6, - 5, - 7, - 4, - 5, - 6, - 5, - 6, - 4, - 7, - 7, - 6, - 5, - 6, - 6, - 7, - 6, - 6, - 6, - 6, - 6, - 354, - 9, - 9, - 9, - 71, - 33, - 34, - 34, - 37, - 56, - 57, - 24, - 63, - 34, - 42, - 56, - 26, - 34, - 34, - 42, - 56, - 62, - 34, - 42, - 56, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 532, - 24, - 33, - 34, - 42, - 56, - 471, - 472, - 308, - 26, - 56, - 415, - 34, - 37, - 55, - 26, - 24, - 24, - 24, - 34, - 57, - 9, - 34, - 34, - 42, - 9, - 34, - 42, - 56, - 57, - 71, - 34, - 34, - 37, - 42, - 55, - 62, - 9, - 33, - 34, - 34, - 42, - 56, - 57, - 34, - 63, - 34, - 56, - 57, - 26, - 24, - 26, - 24, - 24, - 33, - 34, - 37, - 42, - 57, - 24, - 34, - 34, - 33, - 42, - 55, - 62, - 9, - 24, - 24, - 34, - 34, - 33, - 24, - 42, - 56, - 57, - 26, - 34, - 34, - 34, - 37, - 42, - 60, - 62, - 31, - 34, - 34, - 34, - 34, - 42, - 56, - 363, - 62, - 26, - 24, - 34, - 36, - 42, - 56, - 55, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 52, - 57, - 62, - 26, - 62, - 33, - 34, - 34, - 68, - 42, - 52, - 9, - 26, - 33, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 33, - 34, - 33, - 37, - 56, - 23, - 62, - 62, - 34, - 33, - 34, - 37, - 56, - 245, - 24, - 24, - 34, - 34, - 42, - 56, - 34, - 34, - 33, - 34, - 34, - 42, - 56, - 57, - 9, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 71, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 24, - 26, - 62, - 34, - 34, - 34, - 68, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 55, - 24, - 10, - 24, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 62, - 62, - 34, - 63, - 34, - 34, - 42, - 57, - 9, - 34, - 37, - 62, - 42, - 56, - 55, - 62, - 22, - 55, - 62, - 62, - 24, - 33, - 33, - 34, - 37, - 57, - 9, - 62, - 24, - 33, - 34, - 34, - 33, - 42, - 56, - 55, - 26, - 24, - 68, - 42, - 56, - 57, - 24, - 29, - 62, - 63, - 33, - 33, - 37, - 42, - 56, - 55, - 24, - 62, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 2, - 24, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 9, - 24, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 2, - 24, - 62, - 24, - 24, - 24, - 62, - 63, - 33, - 63, - 37, - 42, - 52, - 57, - 62, - 26, - 63, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 71, - 62, - 33, - 34, - 34, - 37, - 42, - 56, - 327, - 24, - 33, - 34, - 34, - 42, - 56, - 24, - 24, - 26, - 34, - 34, - 34, - 37, - 56, - 55, - 24, - 62, - 24, - 33, - 34, - 34, - 42, - 56, - 57, - 24, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 2, - 61, - 139, - 139, - 140, - 139, - 139, - 141, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 141, - 139, - 140, - 139, - 140, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 142, - 142, - 2, - 2, - 3, - 3, - 3, - 6, - 5, - 5, - 7, - 5, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 7, - 6, - 2, - 5, - 6, - 5, - 4, - 2, - 7, - 5, - 7, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 4, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 2, - 6, - 5, - 2, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 7, - 6, - 6, - 6, - 3, - 5, - 6, - 6, - 5, - 3, - 6, - 5, - 6, - 3, - 6, - 6, - 5, - 7, - 5, - 6, - 291, - 5, - 7, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 7, - 7, - 6, - 5, - 6, - 6, - 6, - 7, - 6, - 5, - 6, - 3, - 5, - 6, - 7, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 6, - 7, - 3, - 6, - 5, - 6, - 6, - 6, - 7, - 8, - 8, - 8, - 8, - 568, - 9, - 9, - 26, - 34, - 63, - 33, - 34, - 42, - 56, - 55, - 24, - 512, - 71, - 24, - 34, - 33, - 34, - 37, - 42, - 559, - 56, - 57, - 26, - 33, - 34, - 34, - 37, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 56, - 57, - 24, - 514, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 24, - 34, - 33, - 33, - 34, - 68, - 42, - 57, - 24, - 293, - 212, - 570, - 573, - 9, - 2, - 2, - 9, - 26, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 23, - 9, - 34, - 37, - 42, - 56, - 24, - 62, - 26, - 24, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 63, - 34, - 42, - 56, - 55, - 24, - 9, - 26, - 34, - 33, - 37, - 42, - 52, - 57, - 24, - 34, - 33, - 34, - 42, - 56, - 57, - 26, - 34, - 34, - 56, - 57, - 62, - 24, - 34, - 34, - 37, - 56, - 55, - 9, - 62, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 160, - 162, - 162, - 161, - 9, - 34, - 34, - 34, - 36, - 42, - 56, - 55, - 29, - 33, - 34, - 34, - 37, - 42, - 56, - 24, - 33, - 34, - 33, - 56, - 57, - 9, - 24, - 34, - 34, - 33, - 42, - 55, - 24, - 24, - 34, - 34, - 37, - 52, - 57, - 24, - 62, - 34, - 42, - 34, - 9, - 52, - 56, - 56, - 24, - 34, - 57, - 61, - 61, - 61, - 24, - 24, - 42, - 26, - 26, - 65, - 34, - 56, - 24, - 34, - 333, - 9, - 34, - 42, - 56, - 24, - 34, - 63, - 56, - 55, - 62, - 34, - 37, - 56, - 34, - 37, - 56, - 57, - 24, - 34, - 34, - 60, - 62, - 24, - 42, - 55, - 9, - 34, - 34, - 63, - 42, - 55, - 26, - 56, - 24, - 34, - 363, - 9, - 62, - 63, - 68, - 24, - 55, - 9, - 9, - 34, - 56, - 55, - 34, - 37, - 55, - 52, - 61, - 9, - 34, - 24, - 57, - 57, - 34, - 34, - 9, - 34, - 62, - 9, - 37, - 9, - 34, - 42, - 62, - 34, - 42, - 62, - 68, - 42, - 62, - 52, - 24, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 169, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 140, - 140, - 169, - 169, - 140, - 140, - 139, - 142, - 142, - 142, - 2, - 3, - 3, - 3, - 3, - 3, - 7, - 7, - 7, - 6, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 574, - 515, - 185, - 227, - 235, - 222, - 575, - 237, - 9, - 9, - 9, - 24, - 34, - 34, - 34, - 37, - 56, - 58, - 58, - 62, - 9, - 34, - 34, - 34, - 34, - 33, - 42, - 56, - 57, - 62, - 2, - 63, - 34, - 34, - 68, - 333, - 56, - 24, - 63, - 34, - 42, - 56, - 55, - 24, - 62, - 24, - 24, - 34, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 24, - 63, - 34, - 34, - 68, - 42, - 56, - 57, - 24, - 34, - 34, - 63, - 34, - 42, - 56, - 357, - 26, - 33, - 34, - 34, - 37, - 42, - 42, - 60, - 62, - 9, - 62, - 34, - 34, - 33, - 68, - 42, - 56, - 55, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 24, - 26, - 24, - 24, - 167, - 576, - 160, - 162, - 124, - 24, - 62, - 34, - 33, - 63, - 68, - 42, - 56, - 57, - 512, - 24, - 34, - 34, - 34, - 42, - 56, - 62, - 2, - 24, - 24, - 34, - 34, - 37, - 26, - 56, - 24, - 2, - 34, - 34, - 34, - 37, - 42, - 9, - 34, - 42, - 37, - 333, - 55, - 34, - 56, - 34, - 42, - 62, - 37, - 33, - 34, - 9, - 42, - 24, - 34, - 37, - 55, - 33, - 34, - 42, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 24, - 34, - 34, - 37, - 42, - 56, - 24, - 26, - 34, - 34, - 9, - 26, - 62, - 34, - 34, - 578, - 57, - 34, - 33, - 34, - 56, - 57, - 24, - 34, - 63, - 42, - 56, - 34, - 34, - 34, - 37, - 42, - 55, - 9, - 31, - 9, - 24, - 34, - 363, - 37, - 42, - 56, - 62, - 26, - 62, - 33, - 34, - 34, - 42, - 56, - 62, - 34, - 34, - 34, - 42, - 56, - 62, - 2, - 63, - 42, - 56, - 57, - 34, - 34, - 34, - 29, - 42, - 55, - 24, - 34, - 37, - 42, - 57, - 34, - 37, - 62, - 34, - 34, - 9, - 34, - 42, - 55, - 62, - 24, - 34, - 34, - 55, - 26, - 33, - 63, - 63, - 42, - 363, - 24, - 26, - 24, - 26, - 33, - 33, - 56, - 55, - 62, - 65, - 34, - 42, - 52, - 24, - 62, - 34, - 56, - 57, - 62, - 34, - 34, - 42, - 55, - 37, - 56, - 24, - 34, - 9, - 63, - 42, - 62, - 56, - 357, - 24, - 34, - 363, - 42, - 551, - 34, - 34, - 34, - 42, - 24, - 34, - 34, - 42, - 62, - 34, - 34, - 42, - 56, - 61, - 61, - 61, - 61, - 61, - 61, - 24, - 34, - 34, - 42, - 33, - 34, - 42, - 34, - 34, - 62, - 24, - 9, - 34, - 37, - 23, - 34, - 34, - 34, - 42, - 55, - 24, - 62, - 62, - 24, - 62, - 34, - 34, - 63, - 56, - 9, - 579, - 24, - 24, - 65, - 34, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 34, - 34, - 34, - 37, - 56, - 55, - 26, - 34, - 34, - 33, - 34, - 42, - 42, - 57, - 24, - 26, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 34, - 34, - 34, - 37, - 56, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 140, - 140, - 140, - 139, - 169, - 140, - 140, - 139, - 139, - 140, - 140, - 140, - 139, - 139, - 139, - 140, - 169, - 142, - 142, - 142, - 142, - 3, - 3, - 5, - 5, - 5, - 5, - 5, - 6, - 7, - 7, - 5, - 7, - 6, - 4, - 6, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 4, - 4, - 5, - 5, - 170, - 6, - 4, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 7, - 3, - 6, - 5, - 6, - 6, - 4, - 5, - 2, - 5, - 6, - 6, - 6, - 7, - 4, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 5, - 6, - 5, - 5, - 4, - 6, - 4, - 4, - 6, - 6, - 5, - 4, - 5, - 2, - 6, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 4, - 6, - 6, - 6, - 5, - 6, - 5, - 5, - 7, - 6, - 5, - 5, - 6, - 7, - 6, - 6, - 5, - 6, - 6, - 5, - 4, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 7, - 5, - 3, - 6, - 4, - 6, - 6, - 6, - 5, - 5, - 7, - 5, - 6, - 5, - 4, - 6, - 6, - 5, - 5, - 5, - 4, - 7, - 6, - 4, - 6, - 6, - 8, - 171, - 8, - 8, - 9, - 580, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 65, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 60, - 24, - 62, - 26, - 24, - 24, - 26, - 33, - 63, - 33, - 37, - 42, - 56, - 55, - 24, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 82, - 582, - 92, - 9, - 2, - 9, - 9, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 62, - 34, - 33, - 34, - 34, - 36, - 42, - 55, - 62, - 26, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 22, - 24, - 34, - 34, - 33, - 42, - 42, - 363, - 24, - 583, - 112, - 9, - 2, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 55, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 363, - 57, - 26, - 33, - 33, - 63, - 33, - 42, - 42, - 527, - 62, - 357, - 24, - 33, - 34, - 34, - 68, - 56, - 55, - 24, - 22, - 24, - 34, - 33, - 37, - 42, - 56, - 62, - 26, - 24, - 34, - 34, - 34, - 24, - 42, - 56, - 55, - 9, - 24, - 33, - 34, - 34, - 36, - 42, - 56, - 55, - 24, - 26, - 34, - 34, - 34, - 33, - 24, - 42, - 56, - 57, - 24, - 9, - 24, - 24, - 34, - 34, - 34, - 36, - 42, - 363, - 24, - 65, - 62, - 24, - 34, - 33, - 34, - 68, - 42, - 56, - 55, - 26, - 24, - 33, - 34, - 34, - 68, - 42, - 56, - 55, - 62, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 33, - 34, - 34, - 68, - 56, - 245, - 24, - 24, - 62, - 9, - 24, - 34, - 63, - 33, - 37, - 42, - 56, - 57, - 71, - 62, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 62, - 62, - 34, - 34, - 33, - 33, - 42, - 42, - 60, - 24, - 24, - 33, - 33, - 34, - 42, - 56, - 57, - 62, - 24, - 24, - 62, - 33, - 34, - 34, - 36, - 42, - 56, - 60, - 57, - 26, - 24, - 33, - 34, - 34, - 68, - 42, - 9, - 62, - 34, - 34, - 42, - 56, - 24, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 357, - 26, - 33, - 34, - 34, - 34, - 68, - 42, - 52, - 62, - 24, - 26, - 62, - 9, - 24, - 24, - 34, - 63, - 34, - 36, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 33, - 33, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 34, - 34, - 42, - 52, - 62, - 71, - 24, - 34, - 63, - 34, - 34, - 42, - 40, - 60, - 62, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 62, - 9, - 34, - 34, - 63, - 24, - 333, - 56, - 551, - 62, - 65, - 34, - 33, - 34, - 34, - 37, - 40, - 62, - 65, - 63, - 9, - 33, - 37, - 34, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 169, - 139, - 142, - 142, - 3, - 61, - 61, - 61, - 61, - 61, - 5, - 6, - 5, - 2, - 4, - 5, - 5, - 5, - 5, - 5, - 4, - 6, - 4, - 6, - 170, - 7, - 7, - 8, - 8, - 8, - 8, - 9, - 10, - 24, - 34, - 63, - 33, - 584, - 42, - 56, - 24, - 34, - 62, - 24, - 34, - 33, - 34, - 42, - 42, - 60, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 227, - 37, - 162, - 161, - 9, - 24, - 34, - 68, - 42, - 52, - 57, - 24, - 26, - 24, - 62, - 63, - 63, - 33, - 42, - 56, - 55, - 9, - 24, - 2, - 34, - 34, - 34, - 42, - 56, - 57, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 62, - 24, - 62, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 9, - 42, - 55, - 62, - 9, - 34, - 34, - 34, - 42, - 62, - 26, - 33, - 34, - 42, - 24, - 24, - 42, - 56, - 9, - 24, - 34, - 34, - 26, - 33, - 24, - 34, - 9, - 24, - 34, - 37, - 42, - 34, - 34, - 24, - 52, - 62, - 9, - 26, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 34, - 63, - 56, - 57, - 377, - 33, - 34, - 34, - 42, - 55, - 2, - 34, - 37, - 52, - 34, - 34, - 56, - 57, - 24, - 71, - 62, - 34, - 33, - 37, - 42, - 56, - 55, - 24, - 34, - 34, - 56, - 62, - 34, - 34, - 42, - 34, - 34, - 42, - 57, - 62, - 63, - 34, - 42, - 62, - 2, - 24, - 24, - 33, - 34, - 34, - 42, - 26, - 33, - 37, - 55, - 62, - 61, - 61, - 61, - 61, - 61, - 33, - 34, - 24, - 34, - 68, - 62, - 42, - 57, - 37, - 56, - 9, - 33, - 33, - 33, - 34, - 24, - 34, - 580, - 63, - 33, - 37, - 24, - 62, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 140, - 169, - 140, - 139, - 169, - 139, - 139, - 169, - 169, - 140, - 139, - 140, - 139, - 140, - 142, - 142, - 2, - 3, - 3, - 2, - 3, - 6, - 5, - 5, - 7, - 6, - 6, - 5, - 6, - 6, - 5, - 5, - 6, - 5, - 6, - 6, - 5, - 2, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 4, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 7, - 6, - 3, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 4, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 7, - 5, - 7, - 5, - 6, - 6, - 6, - 7, - 6, - 6, - 2, - 3, - 6, - 170, - 5, - 5, - 6, - 5, - 7, - 6, - 5, - 6, - 6, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 7, - 6, - 5, - 6, - 7, - 3, - 6, - 4, - 7, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 6, - 5, - 6, - 7, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 7, - 6, - 6, - 7, - 6, - 6, - 5, - 8, - 171, - 171, - 355, - 9, - 377, - 62, - 34, - 34, - 33, - 390, - 42, - 56, - 57, - 24, - 26, - 24, - 34, - 34, - 34, - 42, - 56, - 2, - 71, - 62, - 24, - 71, - 34, - 34, - 34, - 33, - 37, - 42, - 56, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 9, - 9, - 24, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 31, - 26, - 24, - 2, - 34, - 34, - 34, - 42, - 56, - 55, - 9, - 33, - 34, - 34, - 37, - 42, - 60, - 24, - 24, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 9, - 235, - 227, - 587, - 221, - 226, - 304, - 26, - 62, - 34, - 34, - 34, - 63, - 42, - 56, - 57, - 62, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 62, - 24, - 63, - 34, - 34, - 68, - 42, - 56, - 55, - 24, - 24, - 62, - 33, - 34, - 34, - 42, - 56, - 55, - 24, - 65, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 62, - 26, - 24, - 9, - 24, - 34, - 33, - 34, - 24, - 42, - 56, - 55, - 24, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 33, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 52, - 62, - 24, - 24, - 34, - 34, - 63, - 37, - 42, - 56, - 57, - 2, - 24, - 34, - 34, - 42, - 56, - 245, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 62, - 34, - 34, - 33, - 63, - 42, - 56, - 57, - 26, - 34, - 63, - 63, - 37, - 42, - 56, - 55, - 24, - 9, - 24, - 24, - 2, - 62, - 33, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 34, - 33, - 33, - 42, - 56, - 60, - 588, - 24, - 24, - 34, - 37, - 42, - 56, - 57, - 26, - 34, - 34, - 34, - 33, - 42, - 56, - 55, - 24, - 24, - 124, - 24, - 34, - 34, - 33, - 36, - 42, - 245, - 24, - 24, - 34, - 33, - 34, - 37, - 42, - 52, - 62, - 62, - 62, - 26, - 24, - 24, - 34, - 34, - 63, - 34, - 42, - 42, - 56, - 55, - 26, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 9, - 62, - 24, - 33, - 33, - 33, - 42, - 42, - 55, - 62, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 24, - 24, - 24, - 62, - 34, - 34, - 34, - 34, - 68, - 42, - 56, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 52, - 62, - 589, - 24, - 34, - 34, - 63, - 37, - 42, - 56, - 55, - 24, - 71, - 62, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 65, - 34, - 34, - 33, - 34, - 42, - 52, - 62, - 33, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 24, - 34, - 34, - 37, - 590, - 56, - 24, - 22, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 65, - 24, - 33, - 33, - 34, - 42, - 56, - 55, - 31, - 26, - 34, - 34, - 63, - 34, - 42, - 56, - 245, - 57, - 24, - 24, - 24, - 62, - 34, - 34, - 34, - 68, - 42, - 56, - 62, - 9, - 26, - 62, - 33, - 63, - 34, - 42, - 56, - 55, - 24, - 24, - 63, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 26, - 24, - 62, - 63, - 34, - 34, - 42, - 56, - 57, - 105, - 9, - 26, - 24, - 33, - 34, - 37, - 42, - 60, - 24, - 26, - 62, - 34, - 34, - 63, - 68, - 42, - 52, - 24, - 9, - 24, - 9, - 9, - 24, - 61, - 34, - 34, - 37, - 42, - 2, - 24, - 26, - 24, - 34, - 34, - 34, - 24, - 29, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 591, - 22, - 62, - 62, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 26, - 24, - 34, - 34, - 34, - 68, - 42, - 363, - 62, - 62, - 26, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 357, - 62, - 24, - 34, - 63, - 33, - 68, - 42, - 56, - 62, - 24, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 22, - 2, - 24, - 63, - 34, - 33, - 37, - 42, - 56, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 2, - 62, - 24, - 63, - 34, - 34, - 34, - 42, - 243, - 55, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 24, - 24, - 24, - 62, - 34, - 33, - 34, - 42, - 42, - 56, - 57, - 24, - 24, - 63, - 34, - 34, - 33, - 37, - 42, - 56, - 55, - 357, - 24, - 63, - 34, - 34, - 68, - 42, - 56, - 57, - 24, - 24, - 24, - 24, - 9, - 62, - 31, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 62, - 33, - 34, - 63, - 34, - 42, - 56, - 55, - 24, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 24, - 65, - 24, - 34, - 34, - 63, - 37, - 42, - 56, - 24, - 62, - 26, - 71, - 71, - 71, - 71, - 71, - 71, - 71, - 71, - 71, - 71, - 71, - 34, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 24, - 26, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 57, - 24, - 9, - 24, - 33, - 34, - 42, - 56, - 55, - 62, - 2, - 26, - 34, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 62, - 9, - 65, - 65, - 65, - 26, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 62, - 26, - 71, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 62, - 24, - 24, - 33, - 34, - 33, - 37, - 42, - 56, - 57, - 31, - 62, - 63, - 34, - 34, - 34, - 42, - 42, - 363, - 24, - 389, - 26, - 24, - 34, - 33, - 34, - 42, - 56, - 57, - 9, - 9, - 33, - 34, - 9, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 142, - 3, - 3, - 4, - 6, - 6, - 5, - 7, - 7, - 2, - 5, - 7, - 5, - 9, - 37, - 42, - 42, - 56, - 406, - 24, - 65, - 34, - 34, - 24, - 24, - 61, - 61, - 593, - 594, - 9, - 9, - 595, - 2, - 377, - 24, - 24, - 26, - 62, - 34, - 63, - 34, - 42, - 56, - 55, - 24, - 9, - 414, - 315, - 323, - 326, - 326, - 105, - 9, - 9, - 9, - 62, - 33, - 34, - 34, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 527, - 24, - 9, - 9, - 9, - 42, - 56, - 62, - 9, - 26, - 24, - 34, - 63, - 37, - 42, - 55, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 2, - 34, - 63, - 34, - 37, - 42, - 42, - 24, - 9, - 34, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 62, - 24, - 34, - 63, - 33, - 37, - 42, - 56, - 57, - 9, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 62, - 9, - 62, - 62, - 34, - 33, - 34, - 42, - 42, - 55, - 24, - 9, - 24, - 34, - 33, - 42, - 42, - 245, - 57, - 24, - 26, - 24, - 34, - 33, - 33, - 37, - 42, - 363, - 57, - 26, - 33, - 34, - 34, - 34, - 37, - 56, - 245, - 62, - 313, - 24, - 62, - 34, - 34, - 33, - 68, - 42, - 56, - 57, - 533, - 2, - 61, - 596, - 598, - 607, - 22, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 31, - 24, - 24, - 332, - 23, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 26, - 34, - 24, - 63, - 37, - 42, - 56, - 57, - 62, - 24, - 608, - 426, - 427, - 428, - 611, - 613, - 616, - 619, - 619, - 621, - 621, - 633, - 637, - 640, - 643, - 9, - 9, - 9, - 71, - 9, - 113, - 2, - 9, - 62, - 33, - 33, - 34, - 42, - 40, - 55, - 62, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 140, - 142, - 142, - 3, - 3, - 3, - 3, - 5, - 6, - 6, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 5, - 5, - 7, - 7, - 6, - 7, - 6, - 5, - 6, - 6, - 5, - 5, - 5, - 5, - 4, - 5, - 6, - 7, - 6, - 5, - 5, - 6, - 170, - 7, - 6, - 5, - 5, - 6, - 6, - 7, - 6, - 4, - 6, - 6, - 6, - 6, - 7, - 6, - 7, - 7, - 5, - 5, - 6, - 6, - 5, - 7, - 6, - 5, - 7, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 3, - 6, - 6, - 5, - 4, - 7, - 5, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 5, - 6, - 5, - 5, - 4, - 5, - 5, - 6, - 6, - 7, - 6, - 5, - 6, - 5, - 7, - 5, - 7, - 5, - 7, - 5, - 6, - 5, - 7, - 7, - 7, - 5, - 6, - 6, - 2, - 7, - 7, - 7, - 5, - 6, - 9, - 644, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 2, - 645, - 392, - 654, - 9, - 135, - 3, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 42, - 56, - 55, - 62, - 657, - 9, - 26, - 24, - 9, - 9, - 62, - 660, - 160, - 162, - 9, - 26, - 33, - 34, - 34, - 34, - 42, - 56, - 245, - 24, - 9, - 26, - 24, - 34, - 34, - 63, - 37, - 42, - 55, - 62, - 34, - 34, - 33, - 63, - 42, - 245, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 24, - 24, - 34, - 55, - 33, - 9, - 2, - 34, - 26, - 23, - 533, - 9, - 34, - 42, - 56, - 62, - 52, - 425, - 425, - 427, - 427, - 427, - 427, - 669, - 674, - 9, - 9, - 2, - 34, - 34, - 33, - 42, - 56, - 55, - 9, - 52, - 62, - 62, - 24, - 62, - 34, - 37, - 56, - 24, - 471, - 353, - 34, - 34, - 34, - 34, - 42, - 56, - 24, - 62, - 24, - 34, - 34, - 33, - 68, - 42, - 55, - 9, - 34, - 33, - 34, - 34, - 34, - 34, - 34, - 37, - 42, - 52, - 24, - 327, - 24, - 33, - 42, - 56, - 55, - 24, - 24, - 62, - 579, - 34, - 33, - 37, - 42, - 56, - 57, - 62, - 34, - 33, - 33, - 33, - 42, - 56, - 60, - 62, - 9, - 24, - 24, - 63, - 34, - 37, - 42, - 56, - 57, - 62, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 2, - 24, - 34, - 34, - 42, - 56, - 24, - 19, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 414, - 26, - 34, - 34, - 34, - 42, - 42, - 55, - 24, - 33, - 33, - 34, - 34, - 42, - 56, - 2, - 24, - 24, - 34, - 34, - 33, - 42, - 56, - 363, - 2, - 71, - 62, - 34, - 24, - 34, - 333, - 42, - 55, - 24, - 24, - 9, - 33, - 33, - 33, - 42, - 56, - 57, - 313, - 71, - 34, - 34, - 33, - 397, - 56, - 55, - 24, - 24, - 26, - 34, - 33, - 34, - 68, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 34, - 63, - 37, - 42, - 56, - 57, - 62, - 9, - 24, - 34, - 34, - 34, - 38, - 56, - 57, - 24, - 63, - 34, - 34, - 42, - 42, - 55, - 2, - 34, - 33, - 33, - 34, - 37, - 56, - 55, - 24, - 2, - 26, - 24, - 33, - 34, - 33, - 37, - 42, - 55, - 2, - 62, - 33, - 63, - 34, - 68, - 42, - 55, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 531, - 71, - 63, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 9, - 254, - 9, - 26, - 24, - 34, - 33, - 34, - 42, - 26, - 34, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 9, - 71, - 62, - 9, - 33, - 34, - 34, - 584, - 42, - 56, - 55, - 62, - 24, - 24, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 24, - 71, - 33, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 589, - 26, - 24, - 34, - 34, - 33, - 37, - 56, - 55, - 24, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 9, - 62, - 24, - 63, - 34, - 34, - 34, - 42, - 24, - 62, - 24, - 34, - 63, - 34, - 37, - 42, - 56, - 24, - 24, - 24, - 34, - 34, - 34, - 42, - 42, - 55, - 62, - 9, - 24, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 9, - 33, - 37, - 42, - 26, - 24, - 34, - 34, - 68, - 55, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 9, - 23, - 24, - 34, - 33, - 34, - 37, - 42, - 24, - 62, - 24, - 34, - 63, - 33, - 24, - 24, - 34, - 34, - 37, - 42, - 363, - 2, - 62, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 2, - 34, - 34, - 24, - 377, - 62, - 34, - 34, - 42, - 56, - 57, - 313, - 26, - 24, - 34, - 34, - 42, - 56, - 62, - 63, - 9, - 24, - 62, - 9, - 33, - 34, - 42, - 42, - 60, - 24, - 9, - 34, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 9, - 24, - 34, - 34, - 34, - 68, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 24, - 33, - 34, - 33, - 42, - 44, - 55, - 57, - 24, - 26, - 62, - 34, - 34, - 34, - 34, - 34, - 42, - 42, - 363, - 57, - 580, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 26, - 62, - 9, - 34, - 34, - 33, - 34, - 42, - 55, - 24, - 24, - 26, - 24, - 34, - 37, - 56, - 60, - 24, - 9, - 62, - 63, - 34, - 34, - 333, - 56, - 57, - 24, - 2, - 62, - 34, - 33, - 33, - 42, - 56, - 57, - 24, - 9, - 24, - 33, - 34, - 34, - 42, - 56, - 55, - 62, - 9, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 363, - 62, - 676, - 679, - 679, - 678, - 679, - 678, - 678, - 680, - 681, - 685, - 467, - 693, - 680, - 466, - 695, - 699, - 703, - 707, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 169, - 169, - 139, - 139, - 169, - 139, - 169, - 139, - 139, - 169, - 139, - 169, - 169, - 140, - 139, - 139, - 141, - 140, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 5, - 6, - 5, - 2, - 5, - 6, - 6, - 4, - 6, - 6, - 7, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 6, - 4, - 5, - 6, - 5, - 5, - 4, - 5, - 6, - 7, - 5, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 5, - 5, - 5, - 6, - 6, - 5, - 5, - 3, - 5, - 5, - 5, - 2, - 6, - 5, - 5, - 5, - 7, - 5, - 7, - 6, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 6, - 4, - 6, - 5, - 170, - 6, - 6, - 5, - 5, - 2, - 6, - 7, - 6, - 7, - 5, - 4, - 6, - 5, - 3, - 5, - 6, - 4, - 5, - 7, - 6, - 7, - 4, - 6, - 3, - 4, - 6, - 6, - 7, - 5, - 6, - 6, - 7, - 5, - 7, - 5, - 6, - 6, - 6, - 6, - 6, - 5, - 4, - 5, - 5, - 7, - 5, - 6, - 5, - 5, - 170, - 6, - 6, - 8, - 8, - 8, - 8, - 8, - 2, - 9, - 26, - 24, - 34, - 33, - 34, - 34, - 37, - 42, - 56, - 57, - 414, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 81, - 708, - 2, - 9, - 2, - 24, - 31, - 34, - 34, - 63, - 42, - 56, - 55, - 24, - 24, - 34, - 42, - 56, - 55, - 9, - 26, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 26, - 71, - 34, - 34, - 34, - 37, - 42, - 55, - 24, - 9, - 61, - 34, - 34, - 34, - 34, - 42, - 55, - 31, - 9, - 62, - 34, - 34, - 34, - 37, - 42, - 52, - 57, - 62, - 2, - 24, - 63, - 34, - 63, - 42, - 42, - 55, - 62, - 26, - 62, - 63, - 34, - 42, - 56, - 55, - 9, - 62, - 34, - 34, - 37, - 56, - 55, - 62, - 24, - 33, - 34, - 34, - 34, - 42, - 42, - 55, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 24, - 9, - 62, - 34, - 42, - 56, - 57, - 9, - 42, - 57, - 9, - 26, - 63, - 34, - 34, - 42, - 42, - 24, - 63, - 33, - 34, - 37, - 42, - 60, - 313, - 65, - 24, - 24, - 34, - 33, - 34, - 37, - 56, - 57, - 9, - 24, - 34, - 63, - 34, - 42, - 56, - 55, - 62, - 9, - 24, - 34, - 33, - 34, - 42, - 42, - 56, - 57, - 2, - 26, - 34, - 34, - 34, - 42, - 60, - 24, - 33, - 63, - 33, - 37, - 42, - 56, - 9, - 113, - 711, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 516, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 3, - 5, - 4, - 4, - 5, - 5, - 6, - 6, - 7, - 6, - 5, - 5, - 6, - 6, - 5, - 3, - 5, - 7, - 6, - 6, - 5, - 6, - 6, - 7, - 2, - 5, - 4, - 5, - 5, - 7, - 8, - 171, - 171, - 8, - 568, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 716, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 33, - 9, - 24, - 9, - 37, - 56, - 9, - 9, - 9, - 26, - 62, - 63, - 33, - 56, - 55, - 9, - 33, - 34, - 68, - 56, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 42, - 9, - 33, - 56, - 9, - 23, - 65, - 34, - 34, - 42, - 56, - 9, - 34, - 33, - 34, - 42, - 56, - 55, - 24, - 34, - 63, - 42, - 55, - 9, - 34, - 42, - 56, - 34, - 37, - 24, - 9, - 9, - 42, - 24, - 26, - 24, - 24, - 42, - 56, - 57, - 24, - 34, - 42, - 56, - 9, - 24, - 9, - 34, - 9, - 37, - 24, - 24, - 34, - 34, - 42, - 60, - 42, - 55, - 62, - 34, - 34, - 37, - 56, - 55, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 26, - 34, - 34, - 63, - 42, - 9, - 68, - 9, - 9, - 34, - 397, - 56, - 9, - 42, - 55, - 9, - 9, - 34, - 34, - 33, - 42, - 56, - 57, - 9, - 33, - 37, - 42, - 52, - 24, - 9, - 24, - 34, - 37, - 24, - 9, - 62, - 24, - 34, - 37, - 56, - 55, - 9, - 33, - 34, - 63, - 42, - 56, - 9, - 26, - 34, - 33, - 34, - 34, - 56, - 24, - 26, - 34, - 34, - 34, - 55, - 9, - 24, - 33, - 34, - 37, - 42, - 55, - 9, - 62, - 62, - 24, - 34, - 34, - 42, - 56, - 24, - 62, - 26, - 24, - 34, - 34, - 24, - 42, - 363, - 57, - 24, - 33, - 34, - 71, - 34, - 37, - 56, - 23, - 24, - 24, - 33, - 34, - 36, - 42, - 52, - 2, - 9, - 57, - 23, - 9, - 34, - 33, - 34, - 55, - 24, - 24, - 26, - 34, - 34, - 34, - 24, - 56, - 55, - 62, - 26, - 24, - 33, - 34, - 34, - 37, - 42, - 60, - 24, - 65, - 24, - 34, - 33, - 37, - 37, - 56, - 55, - 62, - 34, - 42, - 56, - 55, - 24, - 718, - 722, - 730, - 26, - 33, - 33, - 34, - 42, - 55, - 9, - 62, - 63, - 34, - 42, - 56, - 55, - 9, - 24, - 742, - 33, - 34, - 55, - 34, - 34, - 37, - 42, - 56, - 24, - 9, - 26, - 34, - 33, - 63, - 34, - 42, - 56, - 55, - 62, - 24, - 62, - 34, - 34, - 63, - 333, - 56, - 363, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 26, - 62, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 62, - 62, - 33, - 34, - 34, - 34, - 42, - 56, - 245, - 24, - 22, - 62, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 26, - 62, - 24, - 24, - 34, - 34, - 24, - 37, - 42, - 245, - 24, - 24, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 55, - 24, - 2, - 62, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 24, - 9, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 55, - 313, - 24, - 24, - 34, - 34, - 34, - 36, - 42, - 56, - 57, - 9, - 71, - 24, - 34, - 34, - 34, - 34, - 42, - 42, - 56, - 57, - 26, - 62, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 167, - 24, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 363, - 24, - 24, - 123, - 24, - 34, - 33, - 34, - 36, - 42, - 56, - 57, - 62, - 9, - 62, - 34, - 34, - 34, - 37, - 56, - 55, - 24, - 26, - 33, - 34, - 34, - 68, - 42, - 56, - 57, - 9, - 26, - 34, - 63, - 34, - 33, - 42, - 743, - 55, - 24, - 62, - 26, - 34, - 34, - 34, - 42, - 56, - 57, - 62, - 34, - 34, - 34, - 42, - 42, - 55, - 26, - 24, - 34, - 63, - 34, - 37, - 42, - 245, - 62, - 26, - 34, - 63, - 33, - 68, - 42, - 55, - 62, - 26, - 63, - 37, - 333, - 55, - 24, - 24, - 33, - 34, - 33, - 68, - 42, - 56, - 9, - 2, - 62, - 34, - 33, - 24, - 333, - 56, - 57, - 9, - 62, - 34, - 34, - 33, - 37, - 42, - 55, - 349, - 9, - 112, - 232, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 574, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 9, - 139, - 140, - 139, - 139, - 139, - 169, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 141, - 139, - 139, - 139, - 139, - 140, - 139, - 139, - 139, - 169, - 140, - 139, - 139, - 169, - 139, - 142, - 142, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 3, - 6, - 4, - 5, - 6, - 5, - 5, - 7, - 7, - 5, - 6, - 5, - 5, - 7, - 4, - 6, - 6, - 5, - 6, - 5, - 7, - 5, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 6, - 7, - 6, - 5, - 6, - 5, - 6, - 5, - 4, - 5, - 6, - 5, - 5, - 6, - 6, - 6, - 6, - 7, - 6, - 5, - 6, - 3, - 5, - 5, - 5, - 6, - 5, - 6, - 6, - 5, - 7, - 6, - 7, - 7, - 5, - 6, - 6, - 6, - 6, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 6, - 4, - 5, - 6, - 4, - 6, - 6, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 7, - 6, - 5, - 5, - 5, - 2, - 6, - 5, - 3, - 7, - 5, - 5, - 6, - 6, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 6, - 6, - 7, - 6, - 2, - 6, - 6, - 6, - 6, - 3, - 5, - 4, - 5, - 6, - 6, - 6, - 5, - 6, - 7, - 5, - 6, - 6, - 5, - 8, - 8, - 171, - 354, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 746, - 518, - 227, - 191, - 747, - 226, - 748, - 9, - 471, - 159, - 162, - 753, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 24, - 24, - 34, - 34, - 9, - 9, - 333, - 57, - 9, - 9, - 33, - 60, - 9, - 9, - 9, - 34, - 34, - 9, - 9, - 33, - 34, - 56, - 57, - 62, - 34, - 34, - 42, - 55, - 9, - 34, - 34, - 37, - 9, - 62, - 63, - 24, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 24, - 34, - 34, - 55, - 9, - 9, - 34, - 333, - 55, - 62, - 9, - 34, - 42, - 24, - 34, - 57, - 9, - 9, - 26, - 24, - 26, - 34, - 34, - 245, - 9, - 26, - 34, - 34, - 42, - 57, - 26, - 24, - 37, - 42, - 56, - 62, - 24, - 24, - 62, - 2, - 62, - 24, - 37, - 24, - 62, - 33, - 40, - 57, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 62, - 2, - 24, - 34, - 37, - 56, - 55, - 9, - 34, - 37, - 55, - 9, - 33, - 34, - 42, - 55, - 62, - 62, - 62, - 34, - 33, - 37, - 42, - 60, - 9, - 62, - 34, - 34, - 42, - 56, - 9, - 34, - 33, - 37, - 42, - 56, - 26, - 34, - 34, - 34, - 42, - 60, - 62, - 62, - 34, - 34, - 34, - 37, - 42, - 60, - 24, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 26, - 62, - 9, - 33, - 34, - 34, - 9, - 24, - 34, - 33, - 55, - 24, - 9, - 24, - 34, - 34, - 34, - 333, - 56, - 62, - 26, - 23, - 34, - 34, - 37, - 42, - 55, - 62, - 24, - 34, - 34, - 34, - 42, - 55, - 24, - 62, - 34, - 34, - 37, - 42, - 52, - 62, - 62, - 34, - 34, - 34, - 37, - 56, - 62, - 9, - 24, - 34, - 56, - 24, - 9, - 34, - 34, - 37, - 42, - 56, - 9, - 62, - 63, - 34, - 34, - 42, - 42, - 57, - 24, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 9, - 62, - 34, - 33, - 42, - 56, - 24, - 26, - 62, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 24, - 62, - 34, - 34, - 37, - 42, - 42, - 52, - 24, - 24, - 9, - 26, - 34, - 33, - 34, - 37, - 525, - 55, - 24, - 26, - 24, - 33, - 34, - 34, - 42, - 56, - 55, - 62, - 65, - 62, - 34, - 34, - 34, - 34, - 37, - 42, - 60, - 31, - 26, - 62, - 63, - 34, - 34, - 37, - 42, - 56, - 57, - 757, - 24, - 24, - 34, - 34, - 34, - 34, - 36, - 42, - 56, - 57, - 9, - 24, - 62, - 34, - 34, - 63, - 37, - 42, - 56, - 57, - 26, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 26, - 34, - 34, - 33, - 34, - 42, - 56, - 55, - 62, - 62, - 24, - 34, - 34, - 34, - 24, - 42, - 55, - 24, - 24, - 26, - 33, - 34, - 34, - 33, - 37, - 42, - 55, - 24, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 24, - 62, - 34, - 63, - 34, - 37, - 42, - 56, - 57, - 9, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 2, - 71, - 24, - 34, - 34, - 34, - 63, - 34, - 37, - 42, - 62, - 9, - 24, - 34, - 33, - 33, - 40, - 56, - 55, - 62, - 9, - 62, - 34, - 34, - 34, - 34, - 42, - 42, - 55, - 24, - 65, - 34, - 33, - 34, - 68, - 42, - 56, - 55, - 24, - 26, - 62, - 34, - 63, - 34, - 42, - 56, - 55, - 758, - 62, - 24, - 34, - 34, - 34, - 390, - 42, - 52, - 24, - 26, - 2, - 34, - 34, - 34, - 34, - 42, - 42, - 52, - 62, - 9, - 62, - 9, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 26, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 62, - 9, - 34, - 63, - 34, - 34, - 33, - 42, - 56, - 57, - 24, - 24, - 71, - 34, - 63, - 33, - 37, - 45, - 57, - 62, - 33, - 34, - 42, - 56, - 57, - 9, - 551, - 34, - 34, - 33, - 34, - 42, - 56, - 57, - 9, - 62, - 34, - 34, - 34, - 37, - 42, - 245, - 62, - 26, - 33, - 63, - 34, - 34, - 42, - 56, - 57, - 62, - 26, - 33, - 34, - 34, - 36, - 42, - 60, - 9, - 508, - 24, - 24, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 140, - 140, - 139, - 139, - 139, - 141, - 141, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 139, - 169, - 140, - 140, - 140, - 140, - 139, - 139, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 5, - 6, - 4, - 7, - 5, - 6, - 6, - 5, - 7, - 6, - 7, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 170, - 6, - 6, - 5, - 5, - 2, - 6, - 5, - 5, - 7, - 5, - 5, - 6, - 6, - 6, - 6, - 6, - 6, - 6, - 6, - 6, - 7, - 6, - 6, - 6, - 7, - 6, - 6, - 5, - 7, - 6, - 4, - 6, - 6, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 4, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 4, - 7, - 5, - 2, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 5, - 6, - 6, - 5, - 5, - 4, - 5, - 5, - 6, - 7, - 5, - 5, - 7, - 5, - 6, - 5, - 6, - 5, - 3, - 7, - 5, - 5, - 6, - 6, - 6, - 6, - 5, - 6, - 7, - 3, - 5, - 6, - 5, - 5, - 6, - 5, - 7, - 6, - 5, - 5, - 5, - 5, - 5, - 7, - 6, - 4, - 4, - 8, - 8, - 8, - 8, - 8, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 382, - 524, - 147, - 160, - 162, - 162, - 415, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 26, - 34, - 42, - 55, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 71, - 9, - 9, - 24, - 34, - 37, - 56, - 57, - 26, - 33, - 52, - 24, - 33, - 42, - 9, - 34, - 37, - 57, - 57, - 9, - 9, - 34, - 9, - 9, - 9, - 9, - 9, - 34, - 33, - 63, - 42, - 56, - 9, - 9, - 9, - 34, - 63, - 34, - 37, - 60, - 24, - 24, - 34, - 63, - 42, - 363, - 9, - 24, - 33, - 34, - 34, - 56, - 57, - 24, - 9, - 33, - 34, - 63, - 42, - 56, - 62, - 62, - 26, - 34, - 34, - 33, - 42, - 56, - 24, - 9, - 34, - 34, - 37, - 42, - 57, - 9, - 63, - 34, - 34, - 42, - 56, - 57, - 9, - 24, - 63, - 63, - 42, - 57, - 9, - 24, - 34, - 34, - 34, - 56, - 55, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 24, - 2, - 63, - 34, - 37, - 56, - 57, - 26, - 24, - 26, - 63, - 33, - 37, - 42, - 55, - 24, - 22, - 33, - 34, - 33, - 42, - 55, - 24, - 62, - 63, - 33, - 42, - 56, - 57, - 62, - 62, - 33, - 33, - 33, - 42, - 52, - 62, - 24, - 63, - 34, - 61, - 42, - 56, - 24, - 24, - 34, - 37, - 42, - 55, - 9, - 24, - 34, - 33, - 34, - 42, - 56, - 55, - 29, - 24, - 26, - 63, - 34, - 34, - 42, - 56, - 57, - 24, - 9, - 24, - 34, - 34, - 34, - 42, - 56, - 24, - 26, - 63, - 33, - 37, - 57, - 9, - 34, - 34, - 37, - 42, - 56, - 62, - 24, - 24, - 34, - 33, - 37, - 56, - 57, - 759, - 24, - 63, - 34, - 34, - 42, - 56, - 2, - 24, - 62, - 26, - 34, - 34, - 33, - 37, - 42, - 55, - 24, - 24, - 24, - 34, - 34, - 34, - 42, - 55, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 24, - 24, - 24, - 34, - 34, - 33, - 34, - 42, - 56, - 57, - 9, - 24, - 34, - 34, - 34, - 37, - 56, - 55, - 357, - 62, - 62, - 34, - 34, - 34, - 36, - 42, - 55, - 62, - 26, - 24, - 63, - 34, - 34, - 37, - 56, - 55, - 2, - 24, - 24, - 26, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 63, - 34, - 34, - 37, - 42, - 55, - 62, - 9, - 24, - 33, - 34, - 34, - 42, - 42, - 363, - 24, - 26, - 24, - 34, - 34, - 37, - 42, - 56, - 62, - 2, - 24, - 34, - 34, - 34, - 37, - 56, - 57, - 2, - 62, - 34, - 34, - 63, - 34, - 42, - 56, - 57, - 62, - 24, - 62, - 34, - 33, - 34, - 37, - 56, - 55, - 9, - 62, - 24, - 26, - 63, - 63, - 34, - 37, - 42, - 56, - 57, - 24, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 62, - 9, - 24, - 33, - 33, - 34, - 42, - 42, - 52, - 57, - 24, - 62, - 63, - 34, - 33, - 37, - 42, - 56, - 62, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 57, - 26, - 24, - 34, - 34, - 33, - 37, - 42, - 52, - 594, - 26, - 62, - 34, - 34, - 34, - 34, - 42, - 56, - 62, - 24, - 24, - 34, - 33, - 42, - 56, - 43, - 62, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 71, - 34, - 33, - 34, - 34, - 42, - 56, - 55, - 24, - 2, - 24, - 34, - 34, - 34, - 24, - 42, - 56, - 24, - 26, - 62, - 34, - 33, - 34, - 33, - 333, - 56, - 55, - 24, - 62, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 57, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 29, - 62, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 56, - 31, - 24, - 26, - 34, - 33, - 34, - 37, - 42, - 56, - 57, - 24, - 26, - 24, - 34, - 63, - 34, - 37, - 42, - 363, - 62, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 62, - 34, - 33, - 34, - 37, - 42, - 56, - 55, - 62, - 71, - 62, - 34, - 63, - 34, - 37, - 42, - 56, - 55, - 471, - 197, - 762, - 226, - 237, - 9, - 24, - 24, - 33, - 63, - 33, - 34, - 42, - 56, - 62, - 26, - 24, - 34, - 33, - 2, - 37, - 333, - 55, - 2, - 24, - 34, - 33, - 34, - 37, - 56, - 55, - 24, - 24, - 34, - 33, - 34, - 42, - 56, - 57, - 62, - 24, - 33, - 34, - 37, - 42, - 60, - 24, - 34, - 34, - 34, - 63, - 42, - 56, - 57, - 26, - 62, - 33, - 34, - 34, - 37, - 56, - 52, - 62, - 26, - 62, - 34, - 2, - 34, - 42, - 56, - 57, - 10, - 34, - 34, - 63, - 42, - 42, - 55, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 332, - 111, - 233, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 61, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 169, - 139, - 139, - 140, - 139, - 139, - 169, - 139, - 169, - 140, - 139, - 140, - 139, - 139, - 139, - 139, - 139, - 139, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 3, - 5, - 6, - 6, - 4, - 6, - 6, - 7, - 7, - 7, - 7, - 6, - 5, - 7, - 4, - 7, - 4, - 6, - 6, - 6, - 5, - 5, - 6, - 7, - 5, - 7, - 5, - 4, - 6, - 7, - 5, - 5, - 6, - 6, - 5, - 5, - 5, - 6, - 7, - 7, - 6, - 6, - 6, - 5, - 6, - 6, - 7, - 6, - 4, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 7, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 6, - 7, - 5, - 5, - 5, - 5, - 6, - 4, - 7, - 5, - 7, - 5, - 6, - 6, - 6, - 6, - 6, - 6, - 5, - 5, - 6, - 5, - 2, - 5, - 4, - 5, - 6, - 7, - 5, - 5, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 7, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 4, - 4, - 5, - 2, - 5, - 4, - 5, - 6, - 6, - 5, - 7, - 5, - 4, - 8, - 8, - 171, - 8, - 8, - 2, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 764, - 213, - 765, - 9, - 9, - 9, - 147, - 160, - 162, - 165, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 26, - 9, - 9, - 9, - 34, - 33, - 57, - 9, - 9, - 9, - 9, - 9, - 37, - 9, - 34, - 34, - 42, - 9, - 24, - 63, - 33, - 56, - 62, - 9, - 33, - 63, - 42, - 9, - 134, - 9, - 34, - 34, - 42, - 57, - 26, - 34, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 62, - 34, - 34, - 34, - 68, - 42, - 57, - 9, - 2, - 34, - 33, - 52, - 24, - 24, - 34, - 34, - 34, - 42, - 363, - 57, - 26, - 62, - 9, - 34, - 34, - 33, - 42, - 56, - 62, - 9, - 24, - 34, - 34, - 42, - 56, - 55, - 24, - 26, - 24, - 63, - 34, - 37, - 42, - 56, - 57, - 24, - 62, - 34, - 33, - 63, - 42, - 52, - 24, - 26, - 24, - 34, - 34, - 37, - 42, - 60, - 24, - 24, - 24, - 34, - 34, - 42, - 56, - 57, - 22, - 62, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 26, - 24, - 34, - 34, - 34, - 34, - 42, - 56, - 57, - 24, - 24, - 34, - 33, - 33, - 37, - 42, - 56, - 24, - 357, - 2, - 34, - 34, - 34, - 42, - 56, - 57, - 9, - 24, - 24, - 34, - 33, - 34, - 37, - 56, - 55, - 24, - 26, - 24, - 33, - 33, - 33, - 42, - 56, - 55, - 26, - 62, - 34, - 34, - 34, - 55, - 57, - 9, - 71, - 62, - 24, - 34, - 33, - 33, - 42, - 56, - 55, - 24, - 26, - 34, - 34, - 33, - 34, - 42, - 9, - 9, - 62, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 24, - 62, - 33, - 34, - 34, - 42, - 56, - 55, - 407, - 26, - 24, - 26, - 63, - 34, - 34, - 42, - 56, - 62, - 24, - 9, - 34, - 63, - 34, - 37, - 42, - 56, - 57, - 62, - 34, - 34, - 34, - 9, - 24, - 63, - 34, - 33, - 37, - 42, - 52, - 57, - 62, - 42, - 56, - 57, - 512, - 26, - 62, - 34, - 33, - 34, - 37, - 42, - 55, - 61, - 61, - 9, - 24, - 9, - 9, - 63, - 34, - 33, - 34, - 42, - 56, - 57, - 9, - 26, - 24, - 34, - 34, - 34, - 37, - 42, - 245, - 9, - 24, - 24, - 26, - 34, - 33, - 33, - 42, - 56, - 55, - 24, - 24, - 24, - 33, - 33, - 34, - 37, - 42, - 55, - 24, - 26, - 24, - 34, - 34, - 42, - 56, - 55, - 62, - 9, - 24, - 34, - 34, - 34, - 37, - 56, - 24, - 9, - 24, - 34, - 37, - 60, - 24, - 63, - 34, - 34, - 42, - 56, - 9, - 34, - 33, - 34, - 37, - 42, - 24, - 9, - 62, - 34, - 34, - 42, - 52, - 9, - 62, - 34, - 34, - 34, - 42, - 56, - 9, - 24, - 26, - 34, - 34, - 34, - 37, - 56, - 363, - 24, - 9, - 42, - 55, - 24, - 26, - 34, - 42, - 56, - 24, - 24, - 63, - 34, - 37, - 56, - 57, - 62, - 62, - 34, - 33, - 34, - 34, - 42, - 56, - 55, - 9, - 24, - 34, - 34, - 34, - 37, - 42, - 363, - 9, - 62, - 24, - 34, - 34, - 42, - 363, - 2, - 62, - 24, - 24, - 63, - 34, - 34, - 42, - 56, - 57, - 62, - 2, - 31, - 34, - 34, - 34, - 42, - 42, - 55, - 24, - 24, - 62, - 34, - 34, - 63, - 37, - 42, - 55, - 24, - 26, - 24, - 34, - 34, - 68, - 42, - 56, - 62, - 26, - 24, - 34, - 34, - 33, - 42, - 56, - 55, - 31, - 26, - 24, - 34, - 34, - 24, - 42, - 56, - 55, - 2, - 24, - 34, - 34, - 34, - 37, - 42, - 55, - 9, - 24, - 34, - 34, - 34, - 68, - 42, - 55, - 62, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 2, - 26, - 62, - 34, - 63, - 34, - 42, - 42, - 55, - 62, - 26, - 24, - 34, - 34, - 34, - 56, - 62, - 9, - 62, - 34, - 34, - 34, - 68, - 42, - 56, - 24, - 26, - 24, - 34, - 34, - 34, - 42, - 56, - 24, - 22, - 34, - 34, - 34, - 42, - 56, - 24, - 34, - 34, - 34, - 42, - 56, - 60, - 22, - 24, - 34, - 33, - 34, - 37, - 42, - 52, - 9, - 24, - 34, - 34, - 34, - 68, - 42, - 56, - 62, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 768, - 113, - 167, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 770, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 140, - 139, - 169, - 139, - 169, - 139, - 169, - 169, - 139, - 169, - 140, - 169, - 139, - 139, - 142, - 142, - 142, - 142, - 3, - 3, - 3, - 3, - 3, - 3, - 6, - 5, - 5, - 7, - 5, - 5, - 2, - 5, - 7, - 6, - 6, - 5, - 5, - 4, - 6, - 5, - 5, - 6, - 5, - 5, - 7, - 5, - 5, - 5, - 5, - 5, - 5, - 6, - 2, - 7, - 6, - 6, - 2, - 5, - 5, - 5, - 6, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 6, - 5, - 5, - 6, - 2, - 5, - 7, - 5, - 4, - 5, - 6, - 5, - 6, - 6, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 6, - 5, - 5, - 7, - 6, - 6, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 4, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 6, - 5, - 6, - 7, - 5, - 7, - 7, - 4, - 5, - 7, - 4, - 5, - 7, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 5, - 5, - 3, - 5, - 4, - 5, - 6, - 6, - 5, - 6, - 5, - 5, - 6, - 6, - 2, - 3, - 4, - 6, - 5, - 5, - 3, - 6, - 6, - 6, - 5, - 7, - 6, - 5, - 5, - 6, - 6, - 3, - 5, - 6, - 5, - 5, - 8, - 8, - 8, - 8, - 9, - 9, - 185, - 235, - 206, - 226, - 9, - 9, - 9, - 9, - 9, - 160, - 162, - 162, - 773, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 24, - 9, - 9, - 33, - 34, - 37, - 743, - 9, - 24, - 9, - 9, - 33, - 42, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 65, - 26, - 62, - 34, - 33, - 37, - 42, - 55, - 9, - 62, - 33, - 34, - 34, - 42, - 55, - 9, - 34, - 33, - 68, - 42, - 57, - 9, - 33, - 34, - 333, - 57, - 24, - 34, - 24, - 37, - 55, - 26, - 24, - 33, - 34, - 42, - 62, - 24, - 34, - 34, - 42, - 9, - 62, - 34, - 42, - 56, - 57, - 24, - 9, - 34, - 33, - 68, - 56, - 24, - 24, - 71, - 34, - 33, - 34, - 37, - 52, - 62, - 34, - 63, - 34, - 56, - 55, - 62, - 24, - 34, - 42, - 56, - 62, - 125, - 34, - 34, - 63, - 60, - 9, - 24, - 34, - 34, - 37, - 42, - 62, - 644, - 24, - 33, - 63, - 37, - 56, - 24, - 9, - 24, - 34, - 34, - 42, - 60, - 57, - 26, - 34, - 37, - 42, - 55, - 9, - 34, - 42, - 56, - 24, - 9, - 33, - 55, - 62, - 9, - 34, - 34, - 42, - 60, - 2, - 24, - 63, - 56, - 57, - 34, - 33, - 42, - 55, - 9, - 24, - 34, - 34, - 40, - 10, - 24, - 34, - 34, - 55, - 9, - 24, - 34, - 34, - 9, - 26, - 62, - 34, - 33, - 37, - 57, - 9, - 62, - 34, - 2, - 56, - 57, - 62, - 9, - 33, - 34, - 42, - 55, - 24, - 9, - 55, - 61, - 61, - 61, - 61, - 61, - 9, - 34, - 34, - 42, - 24, - 62, - 34, - 34, - 42, - 56, - 24, - 34, - 42, - 57, - 34, - 56, - 512, - 62, - 34, - 34, - 42, - 56, - 62, - 33, - 34, - 42, - 56, - 9, - 26, - 34, - 42, - 56, - 24, - 9, - 24, - 37, - 42, - 60, - 2, - 33, - 42, - 57, - 9, - 55, - 9, - 37, - 56, - 9, - 24, - 24, - 34, - 24, - 42, - 363, - 9, - 62, - 34, - 33, - 34, - 42, - 56, - 57, - 24, - 24, - 34, - 34, - 34, - 42, - 56, - 55, - 26, - 62, - 26, - 34, - 34, - 37, - 42, - 55, - 62, - 26, - 34, - 34, - 37, - 56, - 167, - 24, - 34, - 63, - 37, - 42, - 57, - 24, - 26, - 24, - 34, - 33, - 37, - 42, - 56, - 62, - 2, - 24, - 33, - 34, - 34, - 42, - 56, - 62, - 26, - 24, - 34, - 34, - 34, - 42, - 56, - 57, - 2, - 71, - 24, - 34, - 34, - 34, - 42, - 56, - 60, - 9, - 24, - 9, - 34, - 34, - 63, - 37, - 42, - 57, - 2, - 26, - 34, - 34, - 34, - 42, - 363, - 24, - 62, - 9, - 33, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 9, - 34, - 34, - 34, - 34, - 42, - 56, - 55, - 24, - 9, - 71, - 34, - 34, - 33, - 24, - 42, - 56, - 62, - 26, - 62, - 33, - 34, - 34, - 42, - 56, - 57, - 9, - 26, - 24, - 34, - 34, - 33, - 42, - 56, - 24, - 2, - 24, - 34, - 34, - 33, - 37, - 42, - 56, - 57, - 125, - 24, - 63, - 34, - 33, - 36, - 42, - 56, - 57, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 23, - 62, - 34, - 34, - 33, - 34, - 68, - 42, - 55, - 313, - 24, - 62, - 9, - 34, - 34, - 34, - 33, - 42, - 56, - 57, - 24, - 24, - 24, - 34, - 34, - 34, - 9, - 9, - 34, - 31, - 33, - 42, - 56, - 55, - 62, - 9, - 10, - 9, - 9, - 9, - 9, - 26, - 34, - 34, - 33, - 42, - 775, - 57, - 62, - 65, - 62, - 34, - 34, - 34, - 37, - 42, - 55, - 62, - 24, - 34, - 34, - 34, - 33, - 42, - 42, - 56, - 62, - 9, - 42, - 776, - 24, - 62, - 34, - 34, - 34, - 42, - 9, - 71, - 62, - 34, - 34, - 37, - 42, - 52, - 24, - 2, - 9, - 9, - 9, - 580, - 9, - 235, - 197, - 297, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 2, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 138, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 135, - 139, - 139, - 139, - 139, - 139, - 169, - 139, - 139, - 140, - 139, - 140, - 140, - 169, - 139, - 139, - 139, - 169, - 2, - 142, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 142, - 142, - 3, - 3, - 6, - 5, - 5, - 6, - 4, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 5, - 5, - 5, - 6, - 5, - 7, - 7, - 5, - 5, - 5, - 6, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 5, - 5, - 4, - 7, - 5, - 7, - 5, - 7, - 7, - 6, - 5, - 6, - 6, - 5, - 6, - 6, - 6, - 6, - 5, - 5, - 5, - 6, - 5, - 4, - 6, - 5, - 6, - 7, - 5, - 6, - 5, - 5, - 5, - 7, - 5, - 6, - 5, - 5, - 4, - 7, - 5, - 6, - 5, - 5, - 6, - 2, - 7, - 6, - 5, - 5, - 5, - 5, - 6, - 6, - 7, - 6, - 7, - 6, - 6, - 7, - 5, - 6, - 6, - 7, - 5, - 6, - 7, - 6, - 7, - 5, - 6, - 5, - 6, - 5, - 6, - 6, - 6, - 3, - 5, - 5, - 6, - 4, - 7, - 7, - 6, - 6, - 5, - 6, - 7, - 6, - 7, - 5, - 6, - 6, - 6, - 5, - 5, - 5, - 4, - 5, - 6, - 8, - 8, - 171, - 355, - 9, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 61, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 389, - 9, - 564, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 471, - 2, - 235, - 222, - 226, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 777, - 778, - 147, - 571, - 306, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 787, - 2, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 9, - 2 - ], - "timeDeltas": [ - 578125, - 250, - 167, - 125, - 42, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 208, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 208, - 125, - 125, - 167, - 166, - 84, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 500, - 41, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 41, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 250, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 250, - 125, - 166, - 125, - 209, - 208, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 84, - 83, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 42, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 42, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 167, - 166, - 167, - 208, - 167, - 167, - 208, - 208, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 208, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 209, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 83, - 250, - 125, - 125, - 167, - 166, - 250, - 334, - 83, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 333, - 125, - 500, - 375, - 42, - 167, - 208, - 250, - 167, - 250, - 166, - 167, - 250, - 208, - 125, - 167, - 125, - 167, - 250, - 208, - 167, - 208, - 125, - 208, - 167, - 333, - 250, - 292, - 125, - 250, - 250, - 333, - 250, - 167, - 167, - 333, - 250, - 292, - 291, - 250, - 292, - 917, - 291, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 208, - 417, - 250, - 416, - 167, - 125, - 125, - 125, - 208, - 84, - 125, - 166, - 209, - 250, - 1375, - 166, - 167, - 875, - 167, - 375, - 83, - 250, - 83, - 209, - 250, - 208, - 208, - 209, - 208, - 1083, - 250, - 167, - 125, - 250, - 167, - 125, - 416, - 167, - 167, - 958, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 208, - 125, - 125, - 250, - 84, - 166, - 125, - 125, - 125, - 42, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 209, - 166, - 459, - 833, - 125, - 167, - 83, - 125, - 125, - 125, - 208, - 209, - 166, - 209, - 166, - 167, - 1833, - 167, - 125, - 167, - 166, - 292, - 167, - 166, - 209, - 250, - 125, - 333, - 167, - 583, - 250, - 208, - 1625, - 875, - 167, - 83, - 209, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 208, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 292, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 500, - 42, - 125, - 167, - 125, - 166, - 84, - 625, - 83, - 167, - 125, - 166, - 167, - 167, - 208, - 83, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 208, - 250, - 0, - 125, - 167, - 416, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 167, - 458, - 167, - 3250, - 3041, - 2625, - 1209, - 791, - 1042, - 1417, - 1041, - 1584, - 458, - 458, - 334, - 291, - 292, - 292, - 1541, - 584, - 541, - 250, - 334, - 125, - 375, - 458, - 250, - 250, - 458, - 167, - 208, - 167, - 125, - 375, - 208, - 167, - 583, - 292, - 208, - 209, - 375, - 166, - 1000, - 667, - 625, - 1000, - 833, - 375, - 209, - 166, - 2167, - 250, - 333, - 292, - 417, - 208, - 250, - 1000, - 167, - 250, - 250, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 250, - 166, - 8667, - 3083, - 4417, - 1042, - 833, - 125, - 167, - 7333, - 11000, - 3083, - 12834, - 791, - 4709, - 83, - 417, - 666, - 500, - 1542, - 4875, - 167, - 16041, - 2000, - 417, - 6125, - 167, - 8125, - 1458, - 542, - 500, - 166, - 292, - 125, - 417, - 125, - 416, - 584, - 291, - 334, - 291, - 459, - 666, - 5667, - 250, - 2875, - 47833, - 3500, - 3042, - 1667, - 250, - 666, - 1125, - 959, - 3250, - 1916, - 1375, - 250, - 18334, - 2333, - 16583, - 834, - 208, - 208, - 250, - 2125, - 167, - 125, - 1208, - 1292, - 1375, - 417, - 375, - 291, - 167, - 375, - 375, - 167, - 208, - 292, - 125, - 166, - 167, - 167, - 208, - 167, - 208, - 167, - 750, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 209, - 333, - 167, - 291, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 208, - 167, - 167, - 166, - 209, - 166, - 250, - 167, - 208, - 167, - 292, - 875, - 208, - 167, - 166, - 334, - 166, - 125, - 209, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 292, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 250, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 750, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 84, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 250, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 459, - 125, - 125, - 458, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 416, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 833, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 208, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 5458, - 208, - 125, - 167, - 2375, - 125, - 542, - 833, - 1208, - 625, - 167, - 2208, - 125, - 209, - 166, - 125, - 584, - 125, - 166, - 584, - 125, - 125, - 125, - 166, - 1625, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 208, - 208, - 917, - 1208, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 208, - 209, - 166, - 167, - 167, - 291, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 250, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 2542, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 334, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 209, - 250, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 208, - 167, - 250, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 208, - 125, - 125, - 167, - 500, - 166, - 250, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 125, - 166, - 209, - 166, - 167, - 1125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 1042, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 84, - 125, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 167, - 83, - 125, - 125, - 125, - 167, - 583, - 209, - 458, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 83, - 125, - 209, - 333, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 83, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 500, - 334, - 291, - 292, - 42, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 375, - 167, - 41, - 84, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 208, - 125, - 125, - 125, - 167, - 167, - 250, - 166, - 125, - 125, - 167, - 125, - 167, - 83, - 167, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 167, - 208, - 0, - 208, - 167, - 83, - 375, - 334, - 125, - 166, - 167, - 167, - 83, - 125, - 208, - 167, - 208, - 125, - 209, - 208, - 167, - 83, - 167, - 166, - 125, - 125, - 125, - 250, - 167, - 167, - 166, - 1084, - 333, - 125, - 167, - 125, - 125, - 125, - 166, - 209, - 208, - 167, - 125, - 166, - 917, - 167, - 166, - 125, - 250, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 250, - 167, - 167, - 83, - 250, - 167, - 208, - 125, - 167, - 250, - 750, - 708, - 208, - 209, - 250, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 167, - 166, - 167, - 125, - 250, - 125, - 167, - 250, - 125, - 208, - 167, - 125, - 166, - 125, - 209, - 83, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 209, - 208, - 208, - 167, - 125, - 167, - 125, - 166, - 334, - 0, - 1000, - 250, - 166, - 167, - 167, - 125, - 208, - 125, - 125, - 167, - 208, - 83, - 167, - 125, - 2083, - 167, - 125, - 167, - 125, - 291, - 0, - 209, - 291, - 167, - 1167, - 250, - 166, - 3334, - 708, - 167, - 208, - 125, - 167, - 208, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 250, - 1084, - 1291, - 834, - 750, - 208, - 667, - 833, - 250, - 250, - 375, - 333, - 250, - 209, - 250, - 375, - 250, - 500, - 333, - 417, - 583, - 250, - 333, - 792, - 292, - 541, - 334, - 333, - 250, - 167, - 1958, - 167, - 708, - 292, - 125, - 166, - 125, - 250, - 125, - 167, - 167, - 83, - 125, - 125, - 125, - 83, - 334, - 125, - 333, - 167, - 166, - 125, - 250, - 209, - 166, - 125, - 167, - 125, - 208, - 209, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 250, - 41, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 83, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 209, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 83, - 125, - 125, - 375, - 0, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 250, - 167, - 166, - 250, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 208, - 167, - 166, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 83, - 84, - 666, - 167, - 250, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 166, - 167, - 208, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 83, - 84, - 83, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 125, - 209, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 250, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 84, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 208, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 250, - 42, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 83, - 125, - 167, - 83, - 167, - 375, - 167, - 125, - 125, - 208, - 292, - 166, - 125, - 167, - 208, - 125, - 167, - 250, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 292, - 83, - 167, - 167, - 125, - 125, - 166, - 84, - 125, - 166, - 84, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 125, - 208, - 125, - 208, - 167, - 125, - 167, - 250, - 125, - 500, - 166, - 167, - 583, - 167, - 125, - 167, - 166, - 334, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 209, - 125, - 125, - 166, - 125, - 125, - 125, - 375, - 42, - 125, - 250, - 167, - 125, - 208, - 167, - 83, - 208, - 125, - 125, - 292, - 167, - 83, - 167, - 125, - 416, - 0, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 417, - 41, - 125, - 167, - 125, - 42, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 125, - 167, - 166, - 334, - 291, - 167, - 292, - 208, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 208, - 83, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 83, - 167, - 208, - 125, - 167, - 125, - 250, - 333, - 84, - 166, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 292, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 83, - 167, - 125, - 167, - 83, - 167, - 166, - 125, - 167, - 125, - 167, - 250, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 250, - 125, - 167, - 125, - 250, - 250, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 167, - 83, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 250, - 167, - 125, - 208, - 167, - 416, - 167, - 125, - 208, - 167, - 292, - 125, - 125, - 125, - 166, - 209, - 500, - 166, - 417, - 0, - 125, - 125, - 125, - 208, - 167, - 208, - 459, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 208, - 125, - 167, - 167, - 208, - 208, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 83, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 209, - 208, - 125, - 208, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 250, - 167, - 167, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 375, - 125, - 166, - 125, - 167, - 125, - 167, - 83, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 209, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 209, - 166, - 125, - 167, - 292, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 333, - 42, - 125, - 208, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 250, - 458, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 209, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 208, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 291, - 167, - 167, - 791, - 1042, - 292, - 1625, - 125, - 166, - 125, - 334, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 208, - 208, - 42, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 208, - 208, - 292, - 125, - 125, - 167, - 333, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 208, - 84, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 250, - 42, - 208, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 292, - 41, - 209, - 41, - 167, - 417, - 41, - 250, - 42, - 208, - 84, - 166, - 125, - 167, - 250, - 333, - 292, - 125, - 167, - 333, - 83, - 125, - 167, - 167, - 166, - 209, - 83, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 83, - 84, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 41, - 42, - 83, - 84, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 42, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 83, - 42, - 83, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 167, - 250, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 209, - 125, - 83, - 167, - 166, - 167, - 125, - 125, - 375, - 42, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 209, - 41, - 167, - 167, - 125, - 125, - 125, - 166, - 42, - 167, - 166, - 125, - 167, - 167, - 166, - 209, - 125, - 208, - 83, - 167, - 125, - 167, - 166, - 209, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 500, - 84, - 166, - 125, - 292, - 83, - 125, - 167, - 333, - 42, - 250, - 208, - 167, - 208, - 125, - 125, - 167, - 167, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 167, - 167, - 125, - 166, - 42, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 250, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 209, - 208, - 208, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 42, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 41, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 667, - 0, - 166, - 167, - 167, - 250, - 291, - 209, - 166, - 125, - 292, - 292, - 208, - 250, - 250, - 42, - 125, - 125, - 166, - 167, - 125, - 333, - 334, - 41, - 334, - 291, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 250, - 792, - 167, - 125, - 208, - 167, - 250, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 250, - 167, - 125, - 167, - 125, - 83, - 167, - 125, - 375, - 41, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 708, - 125, - 167, - 500, - 375, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 625, - 167, - 167, - 250, - 125, - 125, - 166, - 167, - 125, - 208, - 250, - 167, - 167, - 125, - 333, - 750, - 1333, - 4000, - 1917, - 1875, - 833, - 1500, - 667, - 125, - 667, - 750, - 375, - 666, - 500, - 1125, - 42, - 458, - 334, - 333, - 2125, - 1292, - 750, - 208, - 292, - 166, - 1000, - 292, - 208, - 334, - 333, - 542, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 583, - 250, - 208, - 125, - 125, - 250, - 167, - 125, - 292, - 125, - 166, - 125, - 167, - 208, - 250, - 292, - 208, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 291, - 334, - 208, - 375, - 167, - 125, - 125, - 125, - 250, - 166, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 375, - 125, - 125, - 208, - 167, - 125, - 167, - 166, - 250, - 167, - 167, - 333, - 125, - 125, - 167, - 125, - 166, - 1667, - 125, - 125, - 167, - 166, - 167, - 167, - 791, - 292, - 250, - 292, - 1291, - 1834, - 583, - 2917, - 2250, - 583, - 1208, - 1750, - 1334, - 2708, - 1542, - 125, - 291, - 2417, - 2542, - 458, - 167, - 166, - 167, - 208, - 375, - 1375, - 667, - 500, - 167, - 291, - 167, - 250, - 292, - 250, - 208, - 125, - 208, - 459, - 166, - 167, - 125, - 167, - 1000, - 208, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 250, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 166, - 875, - 834, - 250, - 291, - 417, - 417, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 250, - 292, - 125, - 208, - 125, - 125, - 125, - 167, - 41, - 167, - 125, - 125, - 125, - 208, - 375, - 209, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 167, - 375, - 125, - 208, - 167, - 208, - 167, - 167, - 208, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 209, - 250, - 125, - 166, - 750, - 1334, - 125, - 166, - 125, - 125, - 250, - 375, - 542, - 292, - 500, - 250, - 20750, - 7833, - 14125, - 167, - 18708, - 583, - 78584, - 41833, - 1292, - 8041, - 45834, - 9875, - 8958, - 5500, - 2625, - 3875, - 3333, - 7334, - 2291, - 3667, - 167, - 166, - 209, - 166, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 292, - 708, - 209, - 166, - 167, - 292, - 166, - 209, - 250, - 166, - 209, - 125, - 1208, - 1375, - 1458, - 667, - 125, - 583, - 167, - 583, - 500, - 250, - 125, - 125, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 333, - 167, - 250, - 125, - 167, - 166, - 250, - 167, - 125, - 167, - 375, - 166, - 125, - 250, - 125, - 375, - 125, - 125, - 125, - 167, - 167, - 291, - 1375, - 2334, - 333, - 125, - 167, - 166, - 125, - 1250, - 792, - 208, - 167, - 167, - 166, - 250, - 167, - 208, - 209, - 208, - 125, - 167, - 208, - 167, - 166, - 167, - 375, - 375, - 1083, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 250, - 166, - 167, - 167, - 166, - 167, - 1292, - 125, - 166, - 167, - 167, - 208, - 292, - 333, - 208, - 250, - 167, - 1167, - 125, - 125, - 166, - 125, - 542, - 125, - 167, - 125, - 166, - 125, - 459, - 208, - 125, - 125, - 458, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 541, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 750, - 208, - 167, - 208, - 125, - 208, - 209, - 125, - 166, - 375, - 42, - 250, - 458, - 209, - 208, - 125, - 167, - 583, - 167, - 375, - 458, - 42, - 291, - 209, - 166, - 84, - 208, - 583, - 84, - 250, - 166, - 209, - 250, - 208, - 250, - 125, - 250, - 125, - 167, - 208, - 208, - 167, - 125, - 208, - 125, - 167, - 167, - 625, - 333, - 250, - 167, - 125, - 458, - 333, - 167, - 250, - 458, - 125, - 250, - 125, - 459, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 334, - 958, - 167, - 125, - 166, - 167, - 1667, - 291, - 125, - 250, - 167, - 250, - 333, - 167, - 417, - 666, - 1084, - 2583, - 208, - 15584, - 125, - 125, - 208, - 208, - 1917, - 2875, - 2333, - 209, - 166, - 375, - 1084, - 1666, - 1084, - 4291, - 500, - 250, - 2584, - 7666, - 542, - 2500, - 5583, - 167, - 167, - 250, - 208, - 542, - 166, - 167, - 167, - 250, - 166, - 167, - 333, - 1250, - 250, - 250, - 125, - 250, - 167, - 250, - 292, - 375, - 291, - 250, - 459, - 416, - 209, - 208, - 250, - 167, - 125, - 166, - 167, - 208, - 250, - 167, - 167, - 250, - 208, - 167, - 333, - 3458, - 375, - 334, - 166, - 167, - 167, - 208, - 208, - 167, - 167, - 208, - 292, - 458, - 250, - 292, - 166, - 167, - 333, - 167, - 292, - 6708, - 167, - 125, - 250, - 375, - 166, - 292, - 167, - 291, - 417, - 167, - 250, - 250, - 375, - 708, - 1417, - 2750, - 21541, - 3834, - 1416, - 459, - 166, - 4292, - 4750, - 167, - 208, - 8000, - 500, - 500, - 208, - 209, - 125, - 2833, - 4292, - 5041, - 125, - 84, - 166, - 125, - 125, - 250, - 209, - 166, - 584, - 291, - 542, - 292, - 250, - 208, - 250, - 417, - 125, - 208, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 208, - 167, - 1792, - 166, - 209, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 292, - 166, - 792, - 667, - 125, - 291, - 167, - 125, - 125, - 375, - 125, - 167, - 125, - 125, - 166, - 125, - 250, - 917, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 541, - 125, - 167, - 125, - 167, - 166, - 84, - 166, - 125, - 125, - 167, - 958, - 167, - 292, - 2041, - 167, - 9542, - 250, - 125, - 208, - 250, - 125, - 83, - 125, - 167, - 125, - 208, - 17792, - 583, - 417, - 2708, - 1542, - 625, - 167, - 166, - 334, - 166, - 125, - 375, - 167, - 167, - 541, - 125, - 167, - 125, - 125, - 125, - 125, - 458, - 125, - 167, - 167, - 125, - 166, - 209, - 208, - 125, - 208, - 167, - 167, - 166, - 250, - 167, - 83, - 125, - 167, - 167, - 166, - 167, - 208, - 167, - 167, - 166, - 125, - 167, - 167, - 250, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 209, - 125, - 666, - 167, - 83, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 375, - 208, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 83, - 209, - 208, - 167, - 166, - 209, - 416, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 541, - 125, - 250, - 167, - 125, - 167, - 166, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 250, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 334, - 83, - 125, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 333, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 250, - 167, - 125, - 167, - 166, - 167, - 167, - 41, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 292, - 208, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 41, - 84, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 250, - 1916, - 292, - 292, - 125, - 166, - 3875, - 125, - 709, - 958, - 167, - 1000, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 250, - 125, - 166, - 167, - 83, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 167, - 167, - 250, - 166, - 125, - 167, - 167, - 250, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 42, - 83, - 167, - 125, - 208, - 250, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 375, - 83, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 333, - 42, - 125, - 125, - 166, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 250, - 167, - 208, - 84, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 125, - 166, - 84, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 42, - 83, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 208, - 167, - 167, - 416, - 125, - 84, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 333, - 250, - 125, - 167, - 125, - 125, - 167, - 208, - 333, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 84, - 208, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 334, - 208, - 167, - 1916, - 459, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 333, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 208, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 84, - 125, - 166, - 167, - 83, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 42, - 166, - 250, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 583, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 0, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 83, - 125, - 125, - 167, - 125, - 167, - 83, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 42, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 375, - 0, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 333, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 333, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 166, - 1375, - 167, - 125, - 167, - 250, - 166, - 125, - 459, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 41, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 83, - 417, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 83, - 167, - 375, - 41, - 125, - 209, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 458, - 500, - 167, - 208, - 1500, - 1084, - 875, - 208, - 167, - 208, - 167, - 208, - 167, - 125, - 166, - 125, - 167, - 167, - 83, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 84, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 250, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 125, - 83, - 167, - 125, - 167, - 83, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 83, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 584, - 166, - 209, - 416, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 458, - 83, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 83, - 167, - 250, - 166, - 167, - 125, - 208, - 125, - 167, - 208, - 167, - 208, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 84, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 250, - 125, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 208, - 83, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 291, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 0, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 417, - 458, - 84, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 83, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 250, - 250, - 125, - 83, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 107958, - 5709, - 3583, - 1917, - 13958, - 11333, - 125, - 459, - 1375, - 1125, - 375, - 541, - 375, - 125, - 250, - 375, - 834, - 208, - 167, - 208, - 208, - 292, - 167, - 333, - 458, - 667, - 375, - 500, - 125, - 542, - 41, - 292, - 1917, - 83, - 167, - 125, - 125, - 166, - 625, - 292, - 542, - 708, - 83, - 250, - 167, - 83, - 292, - 125, - 167, - 125, - 125, - 291, - 84, - 125, - 125, - 250, - 333, - 125, - 125, - 125, - 83, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 375, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 750, - 292, - 125, - 1250, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 333, - 334, - 333, - 125, - 208, - 167, - 125, - 458, - 125, - 125, - 167, - 958, - 375, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 209, - 291, - 334, - 83, - 42, - 125, - 250, - 416, - 42, - 83, - 125, - 334, - 41, - 292, - 292, - 208, - 292, - 125, - 166, - 84, - 875, - 625, - 583, - 542, - 83, - 125, - 167, - 125, - 1333, - 125, - 83, - 125, - 167, - 125, - 1458, - 500, - 750, - 167, - 167, - 83, - 125, - 167, - 708, - 1042, - 166, - 125, - 167, - 875, - 2708, - 167, - 375, - 292, - 83, - 125, - 208, - 209, - 125, - 166, - 1292, - 208, - 375, - 209, - 291, - 917, - 750, - 0, - 333, - 250, - 42, - 292, - 250, - 416, - 0, - 250, - 84, - 666, - 1334, - 41, - 292, - 250, - 583, - 292, - 125, - 167, - 208, - 167, - 83, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 84, - 166, - 417, - 458, - 125, - 417, - 0, - 167, - 458, - 167, - 166, - 375, - 42, - 417, - 333, - 375, - 42, - 500, - 208, - 42, - 166, - 167, - 167, - 208, - 167, - 166, - 250, - 500, - 167, - 375, - 42, - 208, - 208, - 167, - 167, - 500, - 0, - 125, - 208, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 250, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 667, - 41, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 250, - 833, - 250, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 83, - 125, - 167, - 125, - 500, - 208, - 84, - 125, - 166, - 167, - 125, - 167, - 291, - 250, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 875, - 167, - 208, - 458, - 542, - 500, - 917, - 500, - 2083, - 875, - 208, - 375, - 125, - 459, - 375, - 833, - 250, - 458, - 167, - 292, - 125, - 208, - 167, - 291, - 167, - 292, - 166, - 250, - 292, - 167, - 416, - 42, - 250, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 333, - 125, - 167, - 125, - 125, - 125, - 416, - 375, - 84, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 166, - 125, - 209, - 291, - 125, - 209, - 166, - 167, - 167, - 125, - 166, - 167, - 500, - 125, - 167, - 208, - 167, - 125, - 166, - 250, - 0, - 167, - 167, - 333, - 167, - 125, - 250, - 125, - 166, - 125, - 125, - 167, - 208, - 459, - 166, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 291, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 625, - 41, - 209, - 208, - 83, - 209, - 166, - 125, - 209, - 666, - 167, - 333, - 125, - 167, - 250, - 125, - 333, - 167, - 417, - 208, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 42, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 167, - 208, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 83, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 250, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 208, - 125, - 167, - 167, - 125, - 250, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 292, - 125, - 125, - 167, - 125, - 125, - 125, - 250, - 125, - 166, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 41, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 292, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 250, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 83, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 375, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 208, - 125, - 167, - 125, - 125, - 250, - 167, - 166, - 209, - 208, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 125, - 250, - 209, - 125, - 166, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 208, - 333, - 167, - 167, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 250, - 209, - 83, - 167, - 125, - 250, - 208, - 167, - 125, - 166, - 84, - 125, - 291, - 167, - 208, - 42, - 167, - 125, - 416, - 167, - 42, - 166, - 459, - 83, - 208, - 292, - 42, - 166, - 209, - 125, - 250, - 125, - 166, - 417, - 125, - 167, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 625, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 291, - 125, - 125, - 125, - 167, - 167, - 208, - 125, - 167, - 625, - 125, - 125, - 125, - 125, - 166, - 250, - 292, - 167, - 541, - 125, - 167, - 208, - 209, - 458, - 125, - 167, - 458, - 125, - 542, - 500, - 166, - 125, - 167, - 250, - 83, - 84, - 250, - 125, - 125, - 166, - 167, - 125, - 333, - 250, - 125, - 125, - 209, - 250, - 166, - 167, - 125, - 167, - 125, - 416, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 292, - 292, - 166, - 209, - 166, - 292, - 1042, - 708, - 417, - 166, - 84, - 208, - 125, - 208, - 125, - 167, - 125, - 83, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 208, - 1958, - 167, - 292, - 208, - 208, - 334, - 166, - 250, - 250, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 167, - 291, - 167, - 167, - 166, - 125, - 167, - 208, - 209, - 291, - 209, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 250, - 125, - 167, - 125, - 125, - 166, - 167, - 208, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 83, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 250, - 167, - 166, - 167, - 167, - 166, - 125, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 125, - 167, - 166, - 167, - 125, - 83, - 167, - 125, - 167, - 125, - 83, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 250, - 250, - 167, - 166, - 250, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 209, - 208, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 84, - 166, - 125, - 125, - 125, - 209, - 208, - 125, - 208, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 84, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 917, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 209, - 83, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 84, - 166, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 209, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 209, - 166, - 84, - 125, - 125, - 250, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 584, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 41, - 84, - 125, - 166, - 84, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 8083, - 1000, - 250, - 2208, - 375, - 4875, - 33875, - 41292, - 34042, - 9625, - 166, - 125, - 542, - 292, - 125, - 166, - 125, - 500, - 125, - 125, - 167, - 4417, - 125, - 1125, - 250, - 208, - 167, - 166, - 292, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 209, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 416, - 167, - 4083, - 125, - 125, - 167, - 167, - 875, - 166, - 125, - 125, - 167, - 1125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 667, - 333, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 459, - 125, - 166, - 417, - 167, - 958, - 167, - 1416, - 375, - 750, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 3417, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 250, - 167, - 166, - 2917, - 167, - 208, - 167, - 125, - 8125, - 23500, - 125, - 1333, - 167, - 208, - 2250, - 583, - 417, - 708, - 2417, - 21958, - 1375, - 167, - 167, - 83, - 125, - 167, - 125, - 166, - 1167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 292, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 292, - 125, - 125, - 125, - 292, - 458, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 42, - 166, - 125, - 209, - 166, - 125, - 167, - 125, - 167, - 83, - 125, - 125, - 167, - 333, - 125, - 167, - 125, - 125, - 208, - 583, - 84, - 250, - 291, - 167, - 83, - 167, - 167, - 125, - 125, - 166, - 792, - 333, - 125, - 209, - 125, - 250, - 125, - 1291, - 125, - 125, - 125, - 84, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 666, - 209, - 166, - 125, - 167, - 167, - 916, - 167, - 125, - 6333, - 750, - 834, - 208, - 167, - 166, - 584, - 125, - 166, - 334, - 291, - 250, - 125, - 209, - 375, - 250, - 125, - 375, - 291, - 375, - 417, - 375, - 167, - 166, - 250, - 375, - 125, - 417, - 250, - 500, - 625, - 708, - 167, - 1917, - 416, - 84, - 375, - 125, - 1250, - 333, - 958, - 542, - 167, - 958, - 292, - 458, - 583, - 292, - 167, - 291, - 875, - 167, - 833, - 5250, - 9500, - 3625, - 375, - 417, - 1042, - 416, - 667, - 625, - 917, - 47958, - 1875, - 14333, - 98709, - 1041, - 2292, - 875, - 167, - 750, - 3833, - 917, - 958, - 30417, - 2458, - 125, - 1500, - 167, - 958, - 125, - 1125, - 333, - 834, - 458, - 292, - 583, - 2417, - 83, - 1500, - 125, - 2042, - 666, - 834, - 166, - 167, - 125, - 583, - 250, - 375, - 667, - 208, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 333, - 84, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 500, - 84, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 292, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 83, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 83, - 208, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 209, - 125, - 166, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 208, - 125, - 125, - 125, - 167, - 417, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 209, - 208, - 125, - 167, - 125, - 125, - 166, - 167, - 208, - 209, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 208, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 334, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 709, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 250, - 167, - 208, - 167, - 208, - 209, - 166, - 167, - 125, - 125, - 208, - 125, - 209, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 167, - 166, - 84, - 208, - 167, - 166, - 125, - 167, - 208, - 209, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 167, - 166, - 167, - 875, - 1000, - 625, - 458, - 125, - 1084, - 833, - 1208, - 750, - 584, - 125, - 125, - 291, - 417, - 375, - 958, - 334, - 250, - 333, - 2042, - 875, - 625, - 791, - 125, - 125, - 1250, - 459, - 166, - 959, - 166, - 417, - 125, - 125, - 167, - 333, - 125, - 167, - 250, - 166, - 167, - 125, - 167, - 291, - 125, - 167, - 125, - 167, - 166, - 459, - 375, - 166, - 167, - 375, - 167, - 875, - 333, - 167, - 250, - 166, - 292, - 125, - 500, - 500, - 292, - 166, - 375, - 334, - 125, - 125, - 166, - 292, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 208, - 167, - 208, - 167, - 167, - 166, - 375, - 250, - 167, - 250, - 333, - 459, - 166, - 500, - 709, - 250, - 125, - 166, - 667, - 208, - 417, - 2000, - 417, - 833, - 833, - 459, - 625, - 166, - 750, - 250, - 167, - 500, - 250, - 167, - 291, - 250, - 209, - 291, - 167, - 208, - 625, - 167, - 167, - 250, - 666, - 167, - 167, - 375, - 250, - 416, - 209, - 208, - 250, - 167, - 208, - 208, - 167, - 458, - 542, - 167, - 958, - 292, - 541, - 459, - 166, - 167, - 375, - 208, - 125, - 167, - 375, - 417, - 166, - 167, - 458, - 209, - 166, - 209, - 208, - 167, - 166, - 167, - 375, - 417, - 208, - 1375, - 792, - 458, - 167, - 250, - 208, - 208, - 167, - 167, - 166, - 334, - 125, - 208, - 125, - 167, - 208, - 167, - 166, - 375, - 250, - 209, - 125, - 166, - 209, - 375, - 166, - 167, - 167, - 166, - 167, - 542, - 166, - 167, - 750, - 167, - 208, - 83, - 125, - 209, - 125, - 125, - 125, - 458, - 250, - 167, - 166, - 125, - 167, - 333, - 167, - 167, - 166, - 167, - 125, - 167, - 375, - 166, - 584, - 0, - 125, - 166, - 167, - 125, - 208, - 292, - 125, - 167, - 166, - 250, - 167, - 125, - 125, - 208, - 167, - 167, - 166, - 167, - 167, - 333, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 83, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 291, - 209, - 166, - 125, - 209, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 84, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 208, - 167, - 167, - 125, - 166, - 167, - 167, - 208, - 125, - 250, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 208, - 167, - 125, - 125, - 416, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 166, - 167, - 83, - 125, - 250, - 125, - 125, - 167, - 208, - 292, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 250, - 208, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 2542, - 208, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 292, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 542, - 2000, - 208, - 167, - 125, - 208, - 167, - 125, - 166, - 125, - 125, - 209, - 208, - 167, - 208, - 83, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 250, - 625, - 500, - 125, - 250, - 125, - 167, - 125, - 125, - 125, - 583, - 1458, - 7209, - 4000, - 1583, - 417, - 166, - 125, - 125, - 167, - 167, - 291, - 167, - 125, - 292, - 125, - 166, - 125, - 250, - 542, - 11250, - 3583, - 59000, - 13334, - 208, - 292, - 125, - 166, - 167, - 250, - 83, - 167, - 167, - 166, - 167, - 125, - 167, - 333, - 1083, - 209, - 833, - 125, - 125, - 208, - 1292, - 208, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 375, - 166, - 125, - 125, - 167, - 458, - 167, - 167, - 166, - 292, - 167, - 166, - 84, - 166, - 125, - 19667, - 2125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 250, - 209, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 459, - 125, - 125, - 166, - 167, - 83, - 625, - 42, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 250, - 125, - 166, - 125, - 167, - 125, - 167, - 291, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 541, - 167, - 167, - 125, - 166, - 209, - 125, - 1083, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 83, - 167, - 2083, - 250, - 292, - 250, - 1875, - 166, - 167, - 125, - 125, - 1167, - 416, - 167, - 500, - 417, - 291, - 250, - 750, - 334, - 416, - 167, - 250, - 167, - 458, - 1625, - 167, - 2333, - 333, - 209, - 166, - 250, - 1709, - 1541, - 750, - 209, - 125, - 291, - 125, - 167, - 333, - 459, - 708, - 333, - 750, - 209, - 125, - 291, - 292, - 125, - 250, - 375, - 167, - 208, - 208, - 167, - 208, - 209, - 166, - 167, - 208, - 167, - 167, - 208, - 333, - 167, - 167, - 208, - 625, - 167, - 166, - 125, - 167, - 125, - 167, - 83, - 375, - 250, - 167, - 250, - 166, - 125, - 167, - 250, - 125, - 125, - 292, - 250, - 291, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 208, - 167, - 125, - 167, - 125, - 125, - 166, - 209, - 166, - 292, - 417, - 166, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 83, - 125, - 125, - 125, - 209, - 166, - 125, - 209, - 125, - 166, - 125, - 84, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 250, - 125, - 167, - 83, - 167, - 291, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 500, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 333, - 167, - 167, - 125, - 333, - 167, - 83, - 167, - 166, - 125, - 125, - 167, - 125, - 250, - 167, - 125, - 125, - 166, - 167, - 208, - 459, - 958, - 208, - 167, - 125, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 375, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 667, - 42, - 125, - 125, - 583, - 1792, - 125, - 958, - 2125, - 4250, - 2083, - 3375, - 2459, - 2833, - 1375, - 2167, - 12333, - 583, - 2000, - 1250, - 1250, - 3209, - 3583, - 875, - 2375, - 208, - 667, - 833, - 2500, - 2334, - 2791, - 5292, - 3708, - 3667, - 3208, - 1125, - 1042, - 3042, - 875, - 1333, - 2042, - 2958, - 833, - 1209, - 125, - 166, - 125, - 167, - 125, - 625, - 292, - 583, - 250, - 250, - 542, - 291, - 167, - 167, - 208, - 250, - 250, - 542, - 166, - 292, - 125, - 583, - 1834, - 1000, - 1541, - 167, - 500, - 625, - 292, - 500, - 1083, - 1708, - 1667, - 125, - 708, - 209, - 125, - 208, - 167, - 166, - 125, - 125, - 167, - 208, - 167, - 125, - 125, - 125, - 708, - 125, - 125, - 125, - 334, - 125, - 666, - 292, - 167, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 833, - 125, - 959, - 12541, - 3959, - 2416, - 375, - 542, - 917, - 208, - 583, - 459, - 166, - 125, - 292, - 583, - 250, - 125, - 167, - 625, - 750, - 125, - 167, - 208, - 208, - 1292, - 208, - 459, - 291, - 584, - 208, - 208, - 167, - 167, - 166, - 167, - 625, - 250, - 125, - 208, - 375, - 125, - 125, - 125, - 334, - 125, - 125, - 208, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 333, - 167, - 125, - 208, - 209, - 166, - 125, - 209, - 125, - 125, - 125, - 208, - 167, - 208, - 125, - 167, - 166, - 167, - 1292, - 125, - 166, - 250, - 250, - 209, - 125, - 333, - 250, - 167, - 583, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 292, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 209, - 125, - 208, - 125, - 125, - 167, - 208, - 125, - 83, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 208, - 125, - 209, - 250, - 208, - 208, - 167, - 167, - 208, - 167, - 166, - 292, - 167, - 27541, - 40959, - 9791, - 250, - 250, - 167, - 2375, - 3583, - 250, - 9500, - 209, - 208, - 125, - 167, - 125, - 583, - 417, - 208, - 208, - 125, - 334, - 166, - 125, - 167, - 417, - 166, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 208, - 2208, - 2042, - 833, - 375, - 584, - 375, - 14250, - 8250, - 2291, - 125, - 209, - 333, - 417, - 250, - 416, - 167, - 292, - 333, - 250, - 375, - 375, - 292, - 166, - 417, - 208, - 167, - 167, - 166, - 167, - 250, - 292, - 208, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 208, - 334, - 125, - 208, - 167, - 250, - 166, - 292, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 292, - 125, - 125, - 166, - 167, - 167, - 333, - 125, - 167, - 125, - 125, - 125, - 291, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 84, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 208, - 125, - 167, - 208, - 209, - 291, - 167, - 125, - 167, - 208, - 167, - 166, - 375, - 125, - 209, - 166, - 209, - 166, - 125, - 84, - 250, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 208, - 125, - 250, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 917, - 166, - 209, - 125, - 166, - 84, - 125, - 166, - 125, - 209, - 166, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 250, - 125, - 584, - 125, - 166, - 167, - 208, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 83, - 209, - 166, - 125, - 167, - 292, - 250, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 334, - 208, - 208, - 250, - 250, - 250, - 167, - 167, - 208, - 167, - 291, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 84, - 125, - 166, - 167, - 250, - 125, - 125, - 125, - 167, - 208, - 250, - 125, - 167, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 208, - 125, - 208, - 167, - 167, - 125, - 208, - 292, - 125, - 166, - 125, - 334, - 125, - 125, - 125, - 375, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 250, - 125, - 125, - 167, - 250, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 625, - 83, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 167, - 250, - 125, - 250, - 417, - 166, - 167, - 208, - 209, - 208, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 250, - 416, - 209, - 125, - 208, - 125, - 167, - 125, - 166, - 417, - 167, - 250, - 166, - 500, - 209, - 375, - 166, - 167, - 458, - 167, - 208, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 292, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 83, - 209, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 208, - 167, - 83, - 250, - 84, - 125, - 125, - 166, - 167, - 125, - 167, - 291, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 292, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 83, - 167, - 125, - 166, - 167, - 167, - 125, - 250, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 250, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 209, - 250, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 250, - 125, - 167, - 166, - 250, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 417, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 250, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 208, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 250, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 209, - 166, - 167, - 167, - 125, - 125, - 166, - 84, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 208, - 125, - 208, - 125, - 125, - 167, - 167, - 208, - 167, - 125, - 125, - 166, - 84, - 125, - 166, - 167, - 167, - 166, - 209, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 208, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 250, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 291, - 84, - 208, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 625, - 125, - 167, - 292, - 208, - 208, - 209, - 166, - 125, - 167, - 167, - 208, - 333, - 125, - 125, - 125, - 167, - 208, - 167, - 167, - 166, - 209, - 125, - 208, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 250, - 167, - 166, - 167, - 167, - 208, - 167, - 166, - 209, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 333, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 208, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 250, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 209, - 125, - 125, - 125, - 208, - 167, - 125, - 125, - 125, - 166, - 209, - 125, - 458, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 1625, - 167, - 333, - 250, - 125, - 167, - 166, - 250, - 334, - 208, - 1000, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 208, - 125, - 167, - 125, - 125, - 167, - 208, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 292, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 83, - 209, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 209, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 208, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 83, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 83, - 208, - 167, - 125, - 208, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 208, - 333, - 167, - 458, - 6667, - 375, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 83, - 167, - 167, - 166, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 84, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 250, - 250, - 208, - 334, - 166, - 209, - 166, - 375, - 125, - 84, - 125, - 416, - 167, - 292, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 250, - 375, - 334, - 125, - 166, - 125, - 125, - 750, - 209, - 125, - 166, - 125, - 209, - 125, - 541, - 125, - 625, - 209, - 166, - 167, - 125, - 292, - 375, - 125, - 833, - 167, - 125, - 208, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 84, - 291, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 292, - 166, - 167, - 125, - 167, - 208, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 166, - 167, - 167, - 250, - 166, - 209, - 125, - 166, - 125, - 250, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 167, - 167, - 291, - 250, - 334, - 125, - 166, - 125, - 167, - 167, - 166, - 250, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 208, - 167, - 167, - 125, - 125, - 125, - 166, - 250, - 125, - 250, - 167, - 250, - 208, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 83, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 83, - 167, - 250, - 125, - 208, - 375, - 167, - 208, - 209, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 209, - 166, - 125, - 167, - 208, - 209, - 208, - 250, - 292, - 166, - 209, - 166, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 250, - 167, - 333, - 708, - 209, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 166, - 167, - 83, - 125, - 125, - 167, - 250, - 125, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 250, - 125, - 209, - 125, - 125, - 166, - 250, - 125, - 125, - 125, - 250, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 83, - 125, - 125, - 125, - 209, - 166, - 167, - 417, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 166, - 125, - 167, - 6958, - 3542, - 1042, - 500, - 1125, - 1125, - 208, - 5125, - 833, - 7084, - 8166, - 3292, - 167, - 3458, - 292, - 4291, - 250, - 3500, - 37000, - 125, - 29459, - 166, - 459, - 125, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 208, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 208, - 84, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 250, - 208, - 125, - 167, - 3875, - 917, - 1416, - 917, - 24042, - 10625, - 2833, - 2500, - 7542, - 666, - 4667, - 1125, - 500, - 667, - 458, - 292, - 458, - 667, - 1625, - 750, - 333, - 167, - 250, - 541, - 1750, - 334, - 166, - 250, - 334, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 375, - 125, - 166, - 125, - 167, - 625, - 375, - 125, - 125, - 167, - 208, - 333, - 167, - 83, - 167, - 167, - 125, - 250, - 125, - 125, - 166, - 500, - 84, - 166, - 125, - 167, - 167, - 250, - 166, - 167, - 250, - 167, - 166, - 167, - 208, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 83, - 167, - 167, - 125, - 250, - 125, - 166, - 125, - 167, - 125, - 125, - 625, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 209, - 250, - 208, - 250, - 125, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 209, - 166, - 167, - 83, - 209, - 125, - 125, - 583, - 125, - 125, - 167, - 291, - 167, - 167, - 208, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 208, - 125, - 167, - 125, - 208, - 125, - 208, - 209, - 166, - 250, - 125, - 125, - 167, - 125, - 250, - 500, - 125, - 125, - 208, - 292, - 125, - 167, - 125, - 125, - 208, - 125, - 208, - 125, - 125, - 459, - 208, - 208, - 417, - 2958, - 292, - 1167, - 333, - 917, - 208, - 792, - 208, - 167, - 83, - 167, - 291, - 667, - 292, - 208, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 125, - 125, - 125, - 167, - 167, - 208, - 167, - 166, - 167, - 83, - 125, - 84, - 208, - 125, - 125, - 125, - 167, - 166, - 875, - 625, - 167, - 125, - 125, - 208, - 125, - 167, - 250, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 250, - 125, - 125, - 125, - 125, - 292, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 292, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 1125, - 375, - 166, - 125, - 209, - 208, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 83, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 41, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 42, - 167, - 208, - 250, - 208, - 167, - 125, - 167, - 208, - 250, - 167, - 125, - 125, - 166, - 167, - 250, - 208, - 334, - 166, - 167, - 125, - 208, - 167, - 208, - 209, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 208, - 167, - 125, - 125, - 250, - 250, - 167, - 166, - 167, - 167, - 208, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 292, - 250, - 333, - 250, - 125, - 250, - 209, - 125, - 166, - 167, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 292, - 292, - 166, - 459, - 125, - 166, - 167, - 125, - 250, - 375, - 208, - 250, - 459, - 250, - 166, - 167, - 125, - 250, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 209, - 125, - 208, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 250, - 125, - 208, - 250, - 167, - 1667, - 3041, - 125, - 209, - 166, - 125, - 125, - 167, - 167, - 291, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 292, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 83, - 125, - 125, - 125, - 209, - 208, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 209, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 250, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 166, - 125, - 167, - 208, - 167, - 125, - 208, - 125, - 84, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 209, - 166, - 167, - 208, - 167, - 83, - 125, - 167, - 167, - 166, - 250, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 84, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 250, - 209, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 167, - 167, - 166, - 125, - 125, - 125, - 209, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 84, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 209, - 125, - 166, - 125, - 209, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 209, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 209, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 250, - 334, - 125, - 166, - 209, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 83, - 167, - 166, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 250, - 167, - 125, - 166, - 125, - 167, - 208, - 125, - 125, - 209, - 166, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 375, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 209, - 166, - 125, - 292, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 84, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 84, - 166, - 167, - 208, - 125, - 125, - 209, - 291, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 250, - 125, - 167, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 209, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 125, - 167, - 166, - 125, - 250, - 167, - 167, - 166, - 250, - 209, - 125, - 166, - 292, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 250, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 125, - 166, - 167, - 125, - 125, - 83, - 167, - 125, - 125, - 208, - 84, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 334, - 208, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 250, - 83, - 167, - 125, - 166, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 15208, - 625, - 375, - 209, - 12791, - 1250, - 3750, - 209, - 208, - 500, - 292, - 625, - 291, - 792, - 792, - 375, - 375, - 1708, - 250, - 458, - 1167, - 2792, - 1583, - 8125, - 1542, - 7208, - 1625, - 292, - 166, - 209, - 333, - 292, - 166, - 125, - 250, - 167, - 250, - 542, - 791, - 125, - 250, - 292, - 250, - 208, - 167, - 125, - 167, - 125, - 291, - 209, - 1000, - 166, - 334, - 500, - 208, - 542, - 2666, - 8125, - 35875, - 959, - 291, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 333, - 167, - 166, - 167, - 167, - 166, - 209, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 2583, - 167, - 125, - 208, - 167, - 375, - 208, - 167, - 125, - 125, - 167, - 250, - 125, - 166, - 167, - 125, - 125, - 167, - 16750, - 10458, - 375, - 125, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 292, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 583, - 542, - 250, - 667, - 1083, - 250, - 625, - 500, - 250, - 292, - 208, - 583, - 250, - 167, - 292, - 958, - 167, - 2291, - 792, - 3042, - 791, - 209, - 1125, - 1375, - 1625, - 1625, - 208, - 333, - 375, - 542, - 292, - 125, - 166, - 667, - 292, - 250, - 333, - 750, - 208, - 334, - 250, - 250, - 250, - 666, - 667, - 208, - 417, - 417, - 166, - 417, - 750, - 292, - 541, - 167, - 125, - 333, - 125, - 250, - 167, - 167, - 208, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 334, - 166, - 250, - 125, - 167, - 125, - 417, - 166, - 167, - 208, - 125, - 209, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 83, - 250, - 333, - 167, - 125, - 167, - 166, - 209, - 166, - 167, - 208, - 167, - 167, - 125, - 208, - 167, - 166, - 125, - 125, - 167, - 125, - 292, - 125, - 166, - 125, - 167, - 208, - 167, - 125, - 208, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 458, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 167, - 166, - 125, - 250, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 166, - 125, - 250, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 83, - 125, - 125, - 125, - 375, - 209, - 125, - 166, - 167, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 208, - 167, - 125, - 166, - 125, - 84, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 625, - 167, - 291, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 125, - 125, - 250, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 167, - 250, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 333, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 209, - 166, - 167, - 208, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 84, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 250, - 167, - 125, - 125, - 125, - 167, - 208, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 208, - 250, - 167, - 83, - 167, - 167, - 125, - 291, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 542, - 125, - 167, - 916, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 209, - 166, - 167, - 167, - 208, - 125, - 167, - 208, - 125, - 500, - 208, - 167, - 208, - 167, - 125, - 208, - 125, - 167, - 167, - 166, - 167, - 125, - 208, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 167, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 250, - 125, - 125, - 209, - 166, - 209, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 375, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 84, - 208, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 375, - 208, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 208, - 208, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 167, - 208, - 208, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 209, - 583, - 167, - 125, - 166, - 209, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 83, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 333, - 125, - 167, - 166, - 125, - 417, - 292, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 208, - 292, - 166, - 209, - 166, - 125, - 250, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 209, - 166, - 167, - 83, - 125, - 167, - 167, - 166, - 167, - 83, - 167, - 125, - 208, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 209, - 83, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 250, - 166, - 167, - 42, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 166, - 125, - 209, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 84, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 83, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 458, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 84, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 625, - 125, - 166, - 125, - 167, - 125, - 167, - 708, - 167, - 291, - 167, - 167, - 166, - 167, - 167, - 125, - 208, - 125, - 167, - 291, - 125, - 167, - 125, - 417, - 0, - 166, - 167, - 250, - 18417, - 4625, - 1583, - 292, - 333, - 22625, - 13625, - 1542, - 3541, - 125, - 9625, - 167, - 26208, - 11209, - 166, - 167, - 208, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 250, - 167, - 40041, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 416, - 167, - 167, - 166, - 84, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 125, - 250, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 250, - 125, - 125, - 125, - 125, - 291, - 84, - 166, - 167, - 167, - 83, - 333, - 167, - 125, - 208, - 125, - 417, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 291, - 167, - 208, - 125, - 167, - 167, - 375, - 125, - 125, - 291, - 125, - 209, - 250, - 166, - 125, - 209, - 250, - 125, - 166, - 125, - 125, - 250, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 292, - 125, - 125, - 125, - 166, - 125, - 209, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 250, - 125, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 84, - 166, - 167, - 167, - 125, - 125, - 333, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 541, - 375, - 167, - 167, - 166, - 125, - 125, - 250, - 167, - 167, - 166, - 334, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 333, - 125, - 167, - 125, - 291, - 125, - 167, - 125, - 208, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 83, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 208, - 125, - 167, - 333, - 167, - 125, - 125, - 166, - 167, - 125, - 208, - 167, - 167, - 250, - 125, - 125, - 375, - 166, - 125, - 167, - 167, - 208, - 167, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 250, - 125, - 167, - 167, - 375, - 125, - 125, - 125, - 541, - 167, - 375, - 167, - 166, - 125, - 125, - 334, - 166, - 125, - 167, - 125, - 375, - 167, - 166, - 125, - 250, - 125, - 167, - 167, - 166, - 167, - 125, - 250, - 167, - 166, - 125, - 125, - 209, - 125, - 208, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 208, - 125, - 375, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 292, - 166, - 209, - 250, - 166, - 209, - 125, - 250, - 125, - 250, - 166, - 334, - 166, - 167, - 292, - 125, - 166, - 125, - 250, - 125, - 167, - 167, - 291, - 125, - 167, - 292, - 208, - 125, - 125, - 333, - 125, - 209, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 250, - 208, - 167, - 125, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 125, - 208, - 84, - 166, - 209, - 166, - 167, - 208, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 333, - 125, - 125, - 250, - 292, - 250, - 166, - 125, - 167, - 250, - 167, - 166, - 167, - 167, - 125, - 208, - 208, - 167, - 167, - 208, - 125, - 208, - 250, - 125, - 417, - 167, - 166, - 334, - 83, - 167, - 125, - 125, - 333, - 125, - 167, - 166, - 125, - 792, - 417, - 250, - 166, - 125, - 167, - 125, - 125, - 208, - 209, - 125, - 250, - 166, - 209, - 125, - 208, - 167, - 166, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 209, - 166, - 125, - 209, - 166, - 209, - 208, - 167, - 166, - 167, - 167, - 166, - 334, - 250, - 208, - 167, - 125, - 125, - 166, - 125, - 167, - 208, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 250, - 166, - 167, - 125, - 208, - 125, - 125, - 167, - 208, - 209, - 166, - 209, - 166, - 167, - 250, - 125, - 83, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 209, - 166, - 167, - 167, - 166, - 125, - 167, - 375, - 167, - 166, - 375, - 542, - 125, - 125, - 167, - 166, - 167, - 208, - 167, - 250, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 208, - 208, - 167, - 125, - 208, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 250, - 125, - 167, - 166, - 209, - 166, - 209, - 166, - 125, - 84, - 166, - 167, - 125, - 83, - 209, - 166, - 125, - 209, - 291, - 1875, - 167, - 83, - 167, - 250, - 125, - 167, - 125, - 166, - 250, - 167, - 167, - 208, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 209, - 166, - 125, - 209, - 166, - 209, - 125, - 250, - 125, - 166, - 125, - 125, - 209, - 125, - 416, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 292, - 208, - 167, - 125, - 166, - 167, - 125, - 167, - 208, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 209, - 125, - 125, - 208, - 125, - 208, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 208, - 125, - 208, - 167, - 125, - 125, - 125, - 167, - 166, - 209, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 125, - 209, - 166, - 167, - 167, - 166, - 250, - 84, - 125, - 125, - 166, - 250, - 167, - 167, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 208, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 208, - 125, - 167, - 208, - 167, - 167, - 125, - 166, - 209, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 41, - 125, - 125, - 167, - 167, - 166, - 167, - 208, - 125, - 167, - 167, - 208, - 167, - 125, - 208, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 209, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 84, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 209, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 42, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 84, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 417, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 500, - 83, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 458, - 125, - 125, - 209, - 208, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 166, - 84, - 250, - 125, - 2458, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 208, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 292, - 166, - 209, - 625, - 250, - 208, - 83, - 167, - 458, - 209, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 10625, - 4958, - 1500, - 1000, - 292, - 375, - 250, - 292, - 1333, - 1208, - 834, - 625, - 458, - 1417, - 541, - 959, - 541, - 500, - 2750, - 500, - 3042, - 1708, - 667, - 1083, - 1834, - 416, - 292, - 375, - 417, - 416, - 459, - 250, - 208, - 208, - 125, - 500, - 209, - 208, - 458, - 6417, - 417, - 2708, - 6417, - 15875, - 875, - 4083, - 33292, - 2291, - 31417, - 4583, - 750, - 2292, - 375, - 708, - 250, - 250, - 292, - 208, - 500, - 167, - 125, - 125, - 292, - 250, - 333, - 250, - 167, - 333, - 125, - 208, - 84, - 375, - 166, - 125, - 167, - 875, - 125, - 500, - 458, - 667, - 250, - 375, - 542, - 458, - 208, - 84, - 166, - 417, - 83, - 209, - 541, - 292, - 125, - 208, - 167, - 83, - 125, - 167, - 167, - 375, - 0, - 291, - 250, - 292, - 42, - 208, - 500, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 83, - 959, - 250, - 375, - 333, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 542, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 208, - 167, - 166, - 167, - 83, - 42, - 125, - 125, - 167, - 5000, - 12208, - 5375, - 6833, - 250, - 625, - 250, - 84, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 209, - 41, - 167, - 167, - 416, - 125, - 292, - 83, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 166, - 375, - 292, - 417, - 208, - 167, - 208, - 125, - 333, - 292, - 83, - 334, - 83, - 333, - 250, - 0, - 292, - 167, - 250, - 83, - 333, - 292, - 42, - 291, - 42, - 375, - 292, - 291, - 334, - 416, - 42, - 250, - 42, - 250, - 250, - 416, - 667, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 500, - 166, - 250, - 84, - 125, - 125, - 166, - 167, - 250, - 500, - 167, - 166, - 500, - 209, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 250, - 167, - 125, - 167, - 125, - 166, - 167, - 83, - 209, - 291, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 209, - 125, - 166, - 167, - 83, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 917, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 209, - 125, - 333, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 167, - 125, - 125, - 167, - 125, - 83, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 250, - 167, - 125, - 208, - 84, - 125, - 166, - 209, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 250, - 208, - 125, - 250, - 125, - 167, - 167, - 166, - 125, - 125, - 209, - 166, - 167, - 167, - 166, - 125, - 125, - 209, - 208, - 167, - 166, - 209, - 166, - 125, - 167, - 167, - 166, - 125, - 209, - 166, - 167, - 167, - 125, - 166, - 125, - 250, - 250, - 125, - 125, - 209, - 125, - 166, - 167, - 125, - 208, - 209, - 166, - 417, - 333, - 42, - 167, - 166, - 125, - 375, - 167, - 167, - 125, - 250, - 291, - 375, - 292, - 83, - 417, - 0, - 625, - 292, - 208, - 167, - 125, - 250, - 250, - 250, - 375, - 41, - 459, - 625, - 291, - 125, - 459, - 291, - 84, - 166, - 292, - 167, - 166, - 167, - 125, - 542, - 291, - 209, - 666, - 125, - 250, - 125, - 125, - 417, - 875, - 125, - 167, - 125, - 291, - 84, - 250, - 125, - 208, - 292, - 166, - 167, - 125, - 250, - 458, - 125, - 167, - 208, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 0, - 125, - 83, - 125, - 209, - 83, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 209, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 459, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 84, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 666, - 42, - 167, - 125, - 125, - 458, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 291, - 42, - 83, - 250, - 125, - 167, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 12125, - 7459, - 3250, - 291, - 250, - 917, - 542, - 958, - 2542, - 416, - 250, - 334, - 458, - 292, - 250, - 250, - 250, - 5833, - 333, - 1625, - 3250, - 125, - 36709, - 15333, - 1625, - 167, - 250, - 166, - 167, - 333, - 42, - 208, - 375, - 375, - 292, - 83, - 334, - 416, - 0, - 375, - 250, - 167, - 375, - 458, - 1125, - 209, - 1916, - 209, - 1000, - 291, - 10542, - 7375, - 8458, - 459, - 208, - 250, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 291, - 250, - 42, - 125, - 333, - 84, - 166, - 375, - 292, - 333, - 42, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 208, - 375, - 250, - 417, - 208, - 167, - 167, - 166, - 125, - 167, - 500, - 125, - 167, - 333, - 125, - 458, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 333, - 84, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 84, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 42, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 83, - 42, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 84, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 84, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 209, - 125, - 125, - 208, - 208, - 125, - 125, - 250, - 125, - 167, - 208, - 167, - 167, - 166, - 834, - 125, - 125, - 166, - 167, - 208, - 125, - 167, - 125, - 167, - 166, - 167, - 83, - 209, - 208, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 375, - 42, - 125, - 125, - 125, - 125, - 667, - 41, - 42, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 292, - 625, - 875, - 416, - 875, - 334, - 166, - 375, - 334, - 333, - 208, - 250, - 375, - 417, - 458, - 250, - 917, - 3000, - 125, - 167, - 125, - 625, - 500, - 500, - 1125, - 416, - 667, - 625, - 375, - 208, - 167, - 250, - 167, - 291, - 167, - 125, - 208, - 250, - 209, - 333, - 167, - 125, - 166, - 167, - 250, - 125, - 708, - 250, - 167, - 292, - 333, - 250, - 125, - 500, - 250, - 625, - 208, - 167, - 167, - 125, - 208, - 333, - 209, - 125, - 333, - 208, - 209, - 208, - 500, - 417, - 208, - 208, - 334, - 250, - 458, - 167, - 166, - 209, - 166, - 459, - 458, - 167, - 625, - 458, - 250, - 250, - 167, - 166, - 167, - 375, - 125, - 208, - 250, - 250, - 125, - 167, - 167, - 250, - 375, - 166, - 167, - 167, - 125, - 208, - 208, - 209, - 208, - 458, - 542, - 125, - 167, - 208, - 167, - 166, - 250, - 125, - 125, - 125, - 167, - 167, - 166, - 209, - 166, - 167, - 125, - 167, - 166, - 417, - 167, - 291, - 125, - 125, - 250, - 250, - 125, - 250, - 250, - 167, - 333, - 125, - 167, - 125, - 292, - 375, - 125, - 250, - 458, - 250, - 375, - 167, - 291, - 125, - 292, - 333, - 250, - 292, - 167, - 375, - 666, - 167, - 125, - 125, - 375, - 167, - 291, - 167, - 250, - 167, - 208, - 250, - 167, - 416, - 167, - 333, - 209, - 166, - 125, - 209, - 125, - 250, - 125, - 583, - 167, - 250, - 250, - 166, - 209, - 166, - 125, - 125, - 167, - 208, - 167, - 208, - 209, - 208, - 417, - 583, - 167, - 208, - 250, - 292, - 166, - 209, - 166, - 167, - 208, - 375, - 167, - 208, - 417, - 167, - 208, - 167, - 166, - 375, - 209, - 208, - 250, - 292, - 1625, - 166, - 1250, - 250, - 584, - 333, - 292, - 541, - 459, - 250, - 166, - 500, - 417, - 333, - 125, - 1167, - 208, - 375, - 375, - 292, - 333, - 292, - 333, - 250, - 250, - 375, - 292, - 333, - 209, - 166, - 167, - 125, - 208, - 250, - 209, - 166, - 167, - 125, - 125, - 167, - 333, - 167, - 125, - 166, - 209, - 166, - 167, - 292, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 250, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 291, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 208, - 208, - 209, - 125, - 250, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 209, - 500, - 125, - 166, - 167, - 125, - 167, - 208, - 125, - 167, - 125, - 166, - 125, - 334, - 41, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 208, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 83, - 167, - 208, - 125, - 208, - 125, - 167, - 250, - 83, - 167, - 167, - 125, - 166, - 125, - 292, - 750, - 167, - 125, - 166, - 125, - 209, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 84, - 125, - 125, - 208, - 167, - 166, - 292, - 125, - 167, - 166, - 167, - 167, - 208, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 250, - 417, - 167, - 166, - 167, - 125, - 167, - 291, - 167, - 167, - 125, - 125, - 208, - 208, - 84, - 166, - 125, - 125, - 250, - 167, - 125, - 83, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 208, - 167, - 250, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 250, - 125, - 166, - 125, - 167, - 167, - 125, - 208, - 917, - 708, - 167, - 208, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 209, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 250, - 209, - 166, - 125, - 209, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 167, - 333, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 83, - 0, - 84, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 208, - 209, - 125, - 166, - 167, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 208, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 125, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 83, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 208, - 209, - 208, - 125, - 458, - 125, - 167, - 125, - 167, - 208, - 167, - 166, - 167, - 167, - 83, - 167, - 125, - 125, - 166, - 167, - 208, - 125, - 125, - 209, - 250, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 209, - 166, - 209, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 1417, - 250, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 291, - 125, - 125, - 125, - 375, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 334, - 83, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 333, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 2500, - 2417, - 5416, - 1709, - 250, - 375, - 166, - 167, - 542, - 166, - 500, - 125, - 292, - 625, - 125, - 292, - 541, - 3084, - 416, - 1167, - 417, - 1750, - 125, - 375, - 666, - 375, - 417, - 375, - 167, - 166, - 542, - 250, - 125, - 375, - 167, - 583, - 125, - 375, - 167, - 208, - 167, - 125, - 125, - 416, - 167, - 542, - 541, - 250, - 1084, - 166, - 459, - 458, - 375, - 375, - 208, - 209, - 375, - 166, - 292, - 292, - 10583, - 17125, - 167, - 208, - 125, - 125, - 2042, - 166, - 125, - 4542, - 417, - 208, - 1042, - 125, - 125, - 291, - 792, - 792, - 333, - 792, - 125, - 1625, - 1916, - 417, - 208, - 2542, - 333, - 2959, - 416, - 417, - 333, - 709, - 250, - 416, - 209, - 291, - 167, - 83, - 417, - 292, - 6500, - 875, - 625, - 166, - 167, - 500, - 167, - 208, - 125, - 208, - 125, - 167, - 500, - 125, - 250, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 209, - 166, - 1375, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 459, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 5041, - 13292, - 9292, - 541, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 208, - 125, - 208, - 292, - 1083, - 209, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 84, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 84, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 458, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 209, - 125, - 166, - 167, - 292, - 541, - 125, - 167, - 167, - 208, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 209, - 83, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 208, - 167, - 125, - 167, - 125, - 291, - 125, - 167, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 83, - 125, - 125, - 167, - 125, - 167, - 250, - 166, - 125, - 125, - 250, - 167, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 208, - 167, - 167, - 125, - 166, - 167, - 250, - 167, - 375, - 166, - 125, - 167, - 208, - 167, - 208, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 209, - 125, - 125, - 125, - 125, - 125, - 208, - 208, - 125, - 84, - 166, - 167, - 125, - 208, - 209, - 166, - 125, - 125, - 167, - 125, - 125, - 250, - 167, - 208, - 250, - 208, - 209, - 125, - 125, - 291, - 250, - 167, - 167, - 125, - 125, - 125, - 208, - 167, - 208, - 292, - 166, - 167, - 333, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 83, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 292, - 42, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 208, - 167, - 167, - 166, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 208, - 125, - 125, - 209, - 208, - 125, - 125, - 292, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 83, - 125, - 125, - 167, - 291, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 83, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 208, - 167, - 125, - 208, - 167, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 209, - 208, - 167, - 125, - 208, - 125, - 167, - 166, - 167, - 167, - 125, - 333, - 125, - 167, - 166, - 125, - 84, - 166, - 167, - 125, - 167, - 166, - 750, - 209, - 250, - 166, - 209, - 125, - 166, - 167, - 208, - 125, - 167, - 167, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 83, - 167, - 167, - 125, - 125, - 250, - 125, - 125, - 1500, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 209, - 208, - 125, - 167, - 125, - 166, - 209, - 166, - 250, - 209, - 0, - 166, - 125, - 125, - 167, - 167, - 166, - 2917, - 1167, - 500, - 458, - 167, - 750, - 791, - 5000, - 1125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 583, - 750, - 250, - 125, - 167, - 166, - 125, - 417, - 542, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 500, - 125, - 125, - 167, - 167, - 1083, - 458, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 250, - 208, - 167, - 417, - 416, - 209, - 125, - 375, - 208, - 167, - 166, - 500, - 417, - 167, - 166, - 167, - 3458, - 334, - 166, - 1334, - 4250, - 24458, - 36875, - 2083, - 25584, - 17625, - 125, - 166, - 250, - 167, - 167, - 208, - 250, - 42, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 1083, - 209, - 166, - 167, - 167, - 125, - 83, - 167, - 583, - 167, - 166, - 125, - 834, - 125, - 125, - 166, - 125, - 167, - 25292, - 4583, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 208, - 250, - 167, - 125, - 167, - 166, - 125, - 84, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 334, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 541, - 167, - 167, - 166, - 125, - 125, - 209, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 84, - 166, - 125, - 167, - 125, - 167, - 83, - 167, - 208, - 125, - 208, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 250, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 292, - 250, - 167, - 250, - 125, - 125, - 125, - 125, - 250, - 166, - 167, - 167, - 125, - 125, - 125, - 250, - 125, - 208, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 209, - 166, - 125, - 167, - 167, - 83, - 167, - 166, - 209, - 166, - 125, - 209, - 458, - 167, - 166, - 84, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 125, - 209, - 166, - 167, - 125, - 167, - 166, - 209, - 83, - 125, - 167, - 166, - 84, - 125, - 125, - 125, - 125, - 291, - 167, - 167, - 125, - 125, - 208, - 208, - 125, - 209, - 125, - 208, - 250, - 125, - 208, - 125, - 167, - 208, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 250, - 292, - 125, - 166, - 167, - 125, - 250, - 250, - 167, - 166, - 125, - 125, - 250, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 333, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 209, - 250, - 125, - 166, - 125, - 209, - 125, - 125, - 166, - 167, - 125, - 208, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 208, - 500, - 292, - 166, - 250, - 167, - 125, - 125, - 208, - 167, - 250, - 167, - 333, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 291, - 167, - 167, - 125, - 208, - 167, - 291, - 167, - 167, - 125, - 125, - 208, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 208, - 167, - 333, - 125, - 125, - 209, - 166, - 125, - 209, - 208, - 208, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 83, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 209, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 250, - 166, - 375, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 83, - 209, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 0, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 250, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 208, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 83, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 250, - 208, - 125, - 167, - 167, - 208, - 500, - 1125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 208, - 375, - 84, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 167, - 83, - 209, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 208, - 458, - 0, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 125, - 167, - 42, - 166, - 84, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 208, - 167, - 208, - 125, - 84, - 125, - 166, - 334, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 209, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 208, - 6625, - 30750, - 13708, - 4500, - 1375, - 2875, - 125, - 4584, - 1916, - 3042, - 25875, - 3208, - 7000, - 2417, - 3083, - 2375, - 209, - 250, - 0, - 708, - 167, - 333, - 125, - 292, - 250, - 291, - 1500, - 292, - 1208, - 1709, - 250, - 666, - 500, - 792, - 167, - 500, - 500, - 41, - 542, - 542, - 166, - 667, - 167, - 166, - 542, - 208, - 24417, - 125, - 417, - 750, - 2125, - 125, - 166, - 1167, - 167, - 208, - 292, - 166, - 209, - 125, - 125, - 166, - 250, - 125, - 167, - 167, - 208, - 167, - 166, - 167, - 167, - 166, - 167, - 250, - 125, - 292, - 208, - 583, - 167, - 208, - 500, - 250, - 167, - 250, - 167, - 125, - 166, - 125, - 292, - 167, - 250, - 208, - 375, - 167, - 125, - 208, - 125, - 167, - 208, - 417, - 250, - 208, - 458, - 167, - 167, - 250, - 208, - 125, - 458, - 417, - 167, - 0, - 500, - 458, - 333, - 375, - 125, - 125, - 334, - 833, - 208, - 167, - 250, - 167, - 333, - 458, - 167, - 83, - 167, - 167, - 166, - 209, - 208, - 208, - 125, - 209, - 208, - 167, - 208, - 208, - 167, - 167, - 166, - 292, - 208, - 167, - 792, - 166, - 417, - 208, - 125, - 292, - 125, - 167, - 166, - 334, - 166, - 334, - 166, - 417, - 125, - 125, - 167, - 208, - 250, - 250, - 167, - 166, - 167, - 208, - 167, - 292, - 208, - 208, - 125, - 209, - 125, - 250, - 166, - 250, - 167, - 333, - 167, - 125, - 333, - 209, - 208, - 333, - 209, - 708, - 125, - 500, - 292, - 291, - 459, - 166, - 417, - 250, - 125, - 208, - 167, - 208, - 125, - 250, - 167, - 333, - 375, - 1292, - 250, - 167, - 291, - 417, - 792, - 291, - 167, - 500, - 375, - 250, - 208, - 334, - 291, - 584, - 166, - 167, - 583, - 584, - 458, - 1250, - 1083, - 1584, - 250, - 375, - 208, - 250, - 208, - 167, - 417, - 166, - 292, - 417, - 1041, - 250, - 584, - 208, - 375, - 208, - 1000, - 292, - 208, - 209, - 708, - 542, - 500, - 291, - 209, - 458, - 500, - 1083, - 84, - 208, - 583, - 209, - 166, - 209, - 166, - 209, - 166, - 125, - 250, - 209, - 125, - 166, - 167, - 167, - 583, - 167, - 291, - 250, - 209, - 208, - 167, - 208, - 333, - 125, - 250, - 167, - 167, - 125, - 375, - 125, - 208, - 125, - 167, - 416, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 209, - 125, - 166, - 125, - 209, - 125, - 166, - 125, - 125, - 292, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 250, - 125, - 375, - 208, - 125, - 125, - 125, - 125, - 250, - 125, - 167, - 208, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 250, - 125, - 208, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 208, - 167, - 208, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 250, - 167, - 417, - 125, - 166, - 709, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 250, - 125, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 83, - 167, - 167, - 166, - 167, - 208, - 167, - 125, - 125, - 125, - 167, - 208, - 167, - 583, - 167, - 125, - 166, - 167, - 125, - 1167, - 166, - 167, - 208, - 250, - 375, - 125, - 167, - 125, - 1083, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 209, - 416, - 209, - 708, - 125, - 500, - 917, - 125, - 125, - 125, - 166, - 1167, - 167, - 208, - 83, - 84, - 83, - 292, - 125, - 416, - 125, - 334, - 291, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 208, - 167, - 583, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 209, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 209, - 166, - 167, - 167, - 83, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 208, - 167, - 208, - 167, - 167, - 166, - 125, - 209, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 208, - 125, - 375, - 292, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 375, - 42, - 125, - 125, - 125, - 167, - 166, - 209, - 125, - 125, - 208, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 209, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 167, - 167, - 125, - 208, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 209, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 959, - 125, - 125, - 166, - 167, - 333, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 250, - 125, - 167, - 167, - 166, - 167, - 125, - 208, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 208, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 1458, - 125, - 125, - 125, - 167, - 125, - 250, - 166, - 209, - 166, - 209, - 291, - 125, - 209, - 166, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 250, - 209, - 125, - 250, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 166, - 209, - 250, - 166, - 125, - 209, - 41, - 84, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 208, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 333, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 333, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 375, - 0, - 166, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 209, - 166, - 167, - 125, - 167, - 208, - 125, - 167, - 208, - 208, - 167, - 208, - 709, - 333, - 125, - 250, - 167, - 166, - 167, - 167, - 166, - 84, - 208, - 167, - 791, - 209, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 167, - 208, - 208, - 209, - 208, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 125, - 84, - 208, - 167, - 125, - 166, - 167, - 958, - 209, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 333, - 167, - 583, - 125, - 167, - 167, - 166, - 84, - 333, - 125, - 125, - 125, - 250, - 167, - 166, - 334, - 291, - 209, - 416, - 125, - 209, - 166, - 334, - 208, - 83, - 209, - 166, - 167, - 167, - 208, - 125, - 167, - 125, - 125, - 166, - 209, - 208, - 208, - 8750, - 125, - 125, - 542, - 125, - 125, - 167, - 166, - 125, - 167, - 208, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 666, - 167, - 167, - 333, - 167, - 166, - 209, - 208, - 167, - 125, - 208, - 292, - 166, - 292, - 167, - 125, - 166, - 334, - 125, - 83, - 167, - 1208, - 167, - 2583, - 2958, - 1042, - 1375, - 1333, - 542, - 1208, - 750, - 1167, - 833, - 2417, - 1083, - 2667, - 750, - 375, - 1292, - 333, - 458, - 417, - 250, - 500, - 417, - 625, - 791, - 125, - 209, - 416, - 375, - 209, - 333, - 167, - 208, - 542, - 375, - 208, - 667, - 458, - 208, - 167, - 125, - 333, - 334, - 333, - 167, - 208, - 458, - 209, - 458, - 417, - 125, - 291, - 167, - 292, - 1458, - 875, - 292, - 666, - 417, - 292, - 125, - 416, - 167, - 375, - 1250, - 958, - 542, - 458, - 417, - 1500, - 667, - 333, - 333, - 1209, - 44416, - 31000, - 292, - 1333, - 959, - 1666, - 2875, - 375, - 1292, - 4917, - 833, - 292, - 5000, - 708, - 500, - 500, - 292, - 583, - 292, - 333, - 2042, - 250, - 500, - 1125, - 166, - 125, - 1625, - 917, - 375, - 208, - 375, - 375, - 84, - 166, - 167, - 208, - 167, - 208, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 208, - 1334, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 84, - 166, - 167, - 83, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 542, - 166, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 209, - 291, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 83, - 209, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 250, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 500, - 125, - 125, - 167, - 708, - 209, - 250, - 166, - 125, - 209, - 208, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 167, - 167, - 166, - 250, - 125, - 125, - 167, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 541, - 1667, - 2917, - 166, - 250, - 209, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 167, - 166, - 167, - 125, - 167, - 166, - 792, - 125, - 250, - 125, - 2833, - 209, - 125, - 166, - 167, - 125, - 125, - 125, - 208, - 167, - 250, - 208, - 625, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 41, - 1042, - 125, - 542, - 166, - 14000, - 11125, - 167, - 167, - 125, - 166, - 84, - 166, - 125, - 209, - 125, - 166, - 292, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 250, - 291, - 167, - 125, - 375, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 250, - 125, - 125, - 166, - 167, - 208, - 167, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 84, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 333, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 250, - 167, - 208, - 125, - 125, - 167, - 417, - 125, - 166, - 500, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 167, - 83, - 167, - 166, - 167, - 83, - 125, - 209, - 125, - 125, - 166, - 84, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 1084, - 125, - 250, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 167, - 166, - 250, - 125, - 167, - 125, - 167, - 208, - 167, - 583, - 917, - 250, - 166, - 209, - 125, - 166, - 84, - 125, - 958, - 792, - 250, - 1208, - 1583, - 209, - 750, - 375, - 416, - 542, - 500, - 1875, - 750, - 417, - 583, - 917, - 458, - 458, - 209, - 375, - 416, - 209, - 375, - 1333, - 542, - 166, - 375, - 167, - 708, - 2417, - 292, - 208, - 250, - 208, - 167, - 208, - 167, - 167, - 125, - 1791, - 459, - 1250, - 1500, - 1125, - 250, - 125, - 250, - 416, - 209, - 208, - 333, - 125, - 334, - 166, - 250, - 667, - 625, - 208, - 167, - 500, - 167, - 166, - 167, - 208, - 167, - 333, - 334, - 166, - 167, - 167, - 708, - 917, - 375, - 125, - 291, - 167, - 208, - 167, - 125, - 167, - 208, - 167, - 166, - 250, - 167, - 208, - 209, - 208, - 208, - 250, - 375, - 375, - 125, - 167, - 583, - 209, - 125, - 791, - 750, - 167, - 208, - 750, - 167, - 167, - 291, - 375, - 334, - 416, - 250, - 209, - 1083, - 625, - 375, - 208, - 125, - 167, - 292, - 166, - 667, - 250, - 208, - 209, - 166, - 209, - 208, - 167, - 166, - 209, - 125, - 333, - 167, - 416, - 167, - 167, - 125, - 333, - 458, - 250, - 209, - 125, - 500, - 666, - 209, - 375, - 375, - 166, - 167, - 292, - 1000, - 250, - 333, - 417, - 875, - 291, - 417, - 375, - 833, - 167, - 125, - 417, - 666, - 1084, - 458, - 292, - 166, - 167, - 250, - 375, - 458, - 292, - 208, - 250, - 292, - 208, - 209, - 166, - 375, - 292, - 208, - 375, - 209, - 791, - 542, - 292, - 166, - 167, - 1375, - 167, - 208, - 917, - 166, - 500, - 292, - 250, - 500, - 208, - 459, - 291, - 125, - 250, - 209, - 208, - 167, - 125, - 166, - 167, - 208, - 250, - 167, - 167, - 333, - 292, - 208, - 875, - 208, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 250, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 208, - 125, - 208, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 208, - 417, - 167, - 83, - 125, - 125, - 375, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 208, - 125, - 125, - 167, - 375, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 208, - 125, - 417, - 1583, - 84, - 166, - 125, - 125, - 459, - 125, - 541, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 167, - 166, - 167, - 125, - 167, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 166, - 209, - 83, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 541, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 208, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 208, - 125, - 167, - 166, - 875, - 125, - 500, - 209, - 125, - 125, - 375, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 209, - 41, - 167, - 125, - 167, - 125, - 208, - 208, - 167, - 167, - 83, - 125, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 84, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 167, - 125, - 166, - 84, - 166, - 250, - 0, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 208, - 167, - 125, - 125, - 166, - 1042, - 167, - 166, - 84, - 166, - 125, - 167, - 292, - 333, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 209, - 458, - 42, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 84, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 291, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 334, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 41, - 125, - 125, - 167, - 125, - 167, - 166, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 208, - 83, - 209, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 41, - 167, - 208, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 250, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 333, - 167, - 166, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 83, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 208, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 208, - 167, - 208, - 167, - 166, - 125, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 209, - 166, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 83, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 458, - 250, - 250, - 125, - 250, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 250, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 291, - 125, - 917, - 792, - 875, - 541, - 3500, - 375, - 1042, - 375, - 125, - 167, - 458, - 125, - 333, - 209, - 375, - 250, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 292, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 292, - 167, - 458, - 4833, - 1917, - 458, - 917, - 17792, - 1666, - 250, - 6792, - 917, - 125, - 166, - 167, - 208, - 167, - 250, - 125, - 167, - 166, - 125, - 209, - 166, - 167, - 125, - 208, - 167, - 375, - 250, - 167, - 166, - 209, - 1916, - 250, - 709, - 2708, - 2708, - 459, - 5708, - 12875, - 21958, - 375, - 167, - 125, - 167, - 125, - 208, - 167, - 166, - 209, - 166, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 500, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 875, - 875, - 250, - 125, - 125, - 250, - 166, - 125, - 125, - 209, - 333, - 208, - 167, - 167, - 125, - 208, - 125, - 1000, - 667, - 250, - 791, - 84, - 2083, - 9000, - 2667, - 1833, - 5000, - 42, - 125, - 166, - 375, - 209, - 208, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 250, - 125, - 250, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 208, - 209, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 834, - 1416, - 292, - 542, - 500, - 1208, - 333, - 209, - 333, - 250, - 333, - 167, - 250, - 458, - 334, - 625, - 166, - 417, - 833, - 750, - 417, - 750, - 250, - 875, - 458, - 1125, - 709, - 458, - 167, - 166, - 875, - 125, - 584, - 1166, - 250, - 84, - 166, - 167, - 167, - 208, - 208, - 125, - 167, - 500, - 250, - 333, - 375, - 167, - 125, - 292, - 166, - 209, - 333, - 208, - 250, - 292, - 458, - 292, - 542, - 125, - 500, - 250, - 208, - 250, - 83, - 209, - 333, - 167, - 83, - 125, - 208, - 209, - 333, - 167, - 458, - 208, - 500, - 125, - 167, - 708, - 125, - 250, - 334, - 291, - 125, - 292, - 292, - 291, - 209, - 83, - 208, - 459, - 166, - 167, - 167, - 500, - 500, - 208, - 375, - 125, - 125, - 333, - 625, - 334, - 1833, - 1000, - 167, - 125, - 833, - 500, - 917, - 666, - 250, - 834, - 208, - 292, - 291, - 167, - 125, - 1167, - 750, - 750, - 708, - 333, - 250, - 209, - 333, - 167, - 250, - 208, - 167, - 125, - 166, - 250, - 459, - 250, - 375, - 208, - 167, - 250, - 208, - 292, - 291, - 167, - 167, - 166, - 167, - 417, - 166, - 167, - 250, - 292, - 416, - 334, - 166, - 625, - 250, - 250, - 167, - 292, - 166, - 542, - 458, - 209, - 208, - 167, - 291, - 167, - 208, - 167, - 125, - 167, - 166, - 167, - 250, - 167, - 208, - 208, - 209, - 125, - 250, - 1041, - 250, - 209, - 291, - 167, - 208, - 167, - 208, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 208, - 333, - 209, - 250, - 250, - 166, - 125, - 167, - 250, - 167, - 166, - 167, - 167, - 333, - 208, - 209, - 166, - 167, - 125, - 125, - 208, - 292, - 542, - 125, - 333, - 167, - 250, - 458, - 292, - 291, - 125, - 209, - 125, - 208, - 292, - 166, - 167, - 250, - 167, - 333, - 167, - 125, - 166, - 167, - 208, - 167, - 125, - 208, - 334, - 208, - 167, - 166, - 167, - 208, - 167, - 167, - 166, - 209, - 166, - 667, - 792, - 83, - 0, - 125, - 125, - 250, - 208, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 166, - 84, - 166, - 125, - 209, - 166, - 125, - 167, - 208, - 209, - 125, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 83, - 208, - 125, - 167, - 208, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 250, - 125, - 208, - 125, - 167, - 375, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 209, - 166, - 125, - 209, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 208, - 125, - 500, - 125, - 375, - 292, - 166, - 167, - 167, - 125, - 166, - 209, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 166, - 125, - 167, - 292, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 208, - 208, - 334, - 125, - 166, - 84, - 208, - 83, - 125, - 167, - 125, - 125, - 167, - 125, - 250, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 209, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 583, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 208, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 209, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 42, - 167, - 125, - 333, - 83, - 209, - 125, - 125, - 166, - 167, - 125, - 125, - 208, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 167, - 125, - 208, - 208, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 334, - 166, - 167, - 125, - 125, - 125, - 250, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 83, - 84, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 292, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 333, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 84, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 83, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 292, - 125, - 291, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 83, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 208, - 167, - 83, - 208, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 83, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 83, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 541, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 209, - 83, - 167, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 83, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 208, - 167, - 125, - 208, - 167, - 167, - 125, - 208, - 208, - 250, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 208, - 625, - 250, - 167, - 166, - 209, - 125, - 166, - 125, - 125, - 250, - 125, - 125, - 125, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 250, - 125, - 125, - 166, - 167, - 208, - 167, - 167, - 166, - 125, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 250, - 125, - 209, - 208, - 125, - 458, - 167, - 125, - 167, - 208, - 208, - 167, - 250, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 125, - 125, - 83, - 167, - 125, - 250, - 83, - 167, - 167, - 208, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 250, - 167, - 208, - 167, - 166, - 209, - 166, - 209, - 166, - 209, - 250, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 416, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 250, - 208, - 167, - 42, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 84, - 166, - 167, - 83, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 3042, - 1708, - 125, - 3334, - 15291, - 750, - 334, - 1916, - 167, - 625, - 458, - 167, - 250, - 375, - 1625, - 292, - 1958, - 1083, - 4042, - 167, - 250, - 541, - 875, - 167, - 167, - 166, - 542, - 125, - 417, - 333, - 542, - 458, - 375, - 375, - 292, - 166, - 209, - 250, - 208, - 250, - 208, - 167, - 792, - 375, - 208, - 417, - 291, - 167, - 542, - 708, - 625, - 500, - 3250, - 1667, - 166, - 9375, - 2250, - 250, - 417, - 1167, - 125, - 250, - 583, - 2917, - 791, - 209, - 166, - 125, - 209, - 208, - 1167, - 208, - 208, - 625, - 209, - 708, - 3500, - 16833, - 1667, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 209, - 125, - 125, - 208, - 167, - 125, - 791, - 167, - 333, - 3375, - 209, - 166, - 167, - 125, - 125, - 708, - 375, - 167, - 167, - 125, - 166, - 167, - 208, - 125, - 209, - 8083, - 11917, - 1000, - 166, - 209, - 500, - 166, - 209, - 375, - 125, - 125, - 166, - 209, - 166, - 125, - 125, - 250, - 167, - 167, - 166, - 125, - 125, - 167, - 250, - 83, - 167, - 125, - 167, - 125, - 250, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 292, - 166, - 667, - 958, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 209, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 209, - 1250, - 541, - 1459, - 250, - 416, - 167, - 250, - 583, - 125, - 167, - 292, - 250, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 208, - 167, - 208, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 166, - 167, - 208, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 250, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 84, - 166, - 167, - 167, - 166, - 250, - 125, - 167, - 125, - 208, - 125, - 167, - 167, - 166, - 84, - 166, - 167, - 125, - 83, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 250, - 208, - 83, - 334, - 41, - 167, - 958, - 292, - 42, - 1625, - 250, - 166, - 42, - 208, - 209, - 291, - 1417, - 1583, - 1542, - 208, - 125, - 250, - 125, - 250, - 209, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 250, - 167, - 167, - 166, - 167, - 458, - 209, - 166, - 167, - 167, - 250, - 166, - 209, - 333, - 83, - 167, - 167, - 125, - 333, - 1250, - 292, - 2208, - 292, - 250, - 166, - 334, - 750, - 333, - 333, - 167, - 167, - 250, - 375, - 125, - 166, - 167, - 292, - 1708, - 417, - 1208, - 583, - 625, - 1000, - 209, - 166, - 167, - 1167, - 666, - 8334, - 666, - 959, - 416, - 459, - 416, - 584, - 375, - 250, - 500, - 166, - 1250, - 417, - 875, - 208, - 167, - 333, - 125, - 250, - 84, - 375, - 375, - 916, - 1042, - 375, - 1708, - 2584, - 125, - 125, - 625, - 250, - 500, - 250, - 166, - 167, - 167, - 166, - 125, - 167, - 208, - 167, - 167, - 250, - 250, - 166, - 209, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 83, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 250, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 208, - 209, - 166, - 167, - 250, - 208, - 209, - 125, - 125, - 125, - 166, - 167, - 167, - 208, - 167, - 83, - 167, - 125, - 208, - 250, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 83, - 167, - 167, - 166, - 125, - 209, - 416, - 334, - 166, - 209, - 125, - 208, - 167, - 125, - 166, - 209, - 125, - 208, - 167, - 125, - 166, - 167, - 167, - 250, - 125, - 291, - 375, - 750, - 125, - 2167, - 125, - 375, - 3750, - 2458, - 792, - 292, - 458, - 1750, - 208, - 167, - 250, - 125, - 292, - 125, - 166, - 167, - 167, - 208, - 167, - 250, - 166, - 209, - 166, - 167, - 208, - 125, - 125, - 167, - 250, - 167, - 250, - 166, - 334, - 541, - 667, - 292, - 125, - 375, - 250, - 1666, - 3834, - 166, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 292, - 42, - 125, - 166, - 167, - 28542, - 24083, - 27500, - 167, - 166, - 167, - 1000, - 125, - 167, - 125, - 166, - 125, - 250, - 250, - 209, - 166, - 167, - 208, - 167, - 1000, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 750, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 500, - 208, - 167, - 166, - 209, - 41, - 167, - 208, - 125, - 167, - 167, - 166, - 167, - 83, - 8084, - 10000, - 1333, - 208, - 167, - 792, - 83, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 83, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 375, - 167, - 125, - 166, - 167, - 250, - 208, - 167, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 208, - 167, - 167, - 208, - 125, - 292, - 125, - 125, - 125, - 166, - 125, - 209, - 458, - 167, - 166, - 125, - 292, - 167, - 166, - 209, - 1166, - 167, - 583, - 750, - 1584, - 1041, - 875, - 167, - 125, - 458, - 459, - 666, - 1000, - 459, - 625, - 750, - 83, - 1125, - 167, - 458, - 500, - 167, - 1250, - 875, - 333, - 667, - 375, - 125, - 333, - 792, - 583, - 1333, - 292, - 208, - 459, - 333, - 167, - 208, - 208, - 167, - 125, - 125, - 1000, - 125, - 167, - 166, - 167, - 375, - 167, - 291, - 125, - 167, - 208, - 250, - 167, - 167, - 125, - 166, - 125, - 209, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 209, - 166, - 292, - 167, - 166, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 209, - 125, - 416, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 375, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 166, - 125, - 125, - 125, - 167, - 250, - 167, - 166, - 167, - 125, - 125, - 167, - 166, - 209, - 125, - 125, - 416, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 209, - 125, - 208, - 167, - 125, - 166, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 125, - 250, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 250, - 125, - 125, - 458, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 292, - 417, - 291, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 250, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 250, - 125, - 125, - 209, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 166, - 209, - 166, - 125, - 167, - 125, - 417, - 166, - 209, - 125, - 125, - 166, - 167, - 125, - 167, - 208, - 125, - 167, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 209, - 166, - 167, - 167, - 125, - 125, - 125, - 583, - 208, - 167, - 750, - 125, - 167, - 250, - 166, - 334, - 166, - 334, - 125, - 125, - 125, - 166, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 209, - 291, - 209, - 166, - 167, - 125, - 167, - 2375, - 166, - 209, - 166, - 209, - 166, - 167, - 125, - 125, - 333, - 167, - 250, - 167, - 166, - 167, - 208, - 334, - 291, - 250, - 834, - 166, - 209, - 208, - 167, - 333, - 208, - 167, - 167, - 125, - 208, - 125, - 333, - 167, - 125, - 208, - 625, - 2459, - 166, - 125, - 167, - 167, - 416, - 125, - 125, - 125, - 209, - 750, - 208, - 167, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 791, - 167, - 167, - 166, - 125, - 167, - 167, - 291, - 125, - 167, - 125, - 167, - 291, - 125, - 292, - 167, - 125, - 166, - 167, - 83, - 125, - 167, - 250, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 292, - 125, - 208, - 167, - 83, - 167, - 125, - 208, - 208, - 167, - 125, - 208, - 125, - 209, - 333, - 250, - 125, - 208, - 209, - 166, - 167, - 125, - 250, - 167, - 125, - 208, - 167, - 208, - 125, - 167, - 166, - 209, - 166, - 125, - 167, - 208, - 125, - 209, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 291, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 209, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 916, - 292, - 125, - 292, - 166, - 167, - 167, - 166, - 167, - 250, - 83, - 250, - 167, - 500, - 167, - 166, - 209, - 125, - 166, - 167, - 208, - 167, - 125, - 167, - 125, - 166, - 542, - 167, - 166, - 625, - 209, - 166, - 167, - 125, - 167, - 166, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 208, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 209, - 250, - 125, - 166, - 125, - 3250, - 125, - 209, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 250, - 167, - 375, - 167, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 125, - 166, - 209, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 41, - 84, - 125, - 208, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 208, - 167, - 167, - 125, - 166, - 125, - 209, - 125, - 208, - 83, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 208, - 292, - 166, - 84, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 250, - 959, - 291, - 167, - 167, - 875, - 166, - 167, - 167, - 166, - 167, - 125, - 208, - 125, - 167, - 167, - 250, - 208, - 167, - 166, - 84, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 209, - 166, - 167, - 125, - 167, - 375, - 125, - 166, - 167, - 208, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 209, - 250, - 166, - 250, - 125, - 209, - 125, - 125, - 166, - 167, - 250, - 125, - 125, - 250, - 125, - 167, - 125, - 208, - 208, - 334, - 166, - 125, - 125, - 167, - 208, - 209, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 208, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 84, - 166, - 167, - 125, - 125, - 167, - 166, - 84, - 166, - 292, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 1167, - 333, - 458, - 125, - 125, - 125, - 375, - 292, - 583, - 1584, - 416, - 584, - 125, - 375, - 125, - 208, - 125, - 167, - 166, - 417, - 167, - 166, - 125, - 209, - 166, - 125, - 125, - 209, - 166, - 167, - 167, - 125, - 166, - 167, - 583, - 209, - 166, - 125, - 334, - 166, - 125, - 250, - 250, - 125, - 209, - 125, - 166, - 167, - 125, - 250, - 167, - 125, - 166, - 209, - 125, - 166, - 167, - 208, - 125, - 167, - 125, - 208, - 167, - 167, - 125, - 166, - 250, - 167, - 167, - 208, - 167, - 125, - 166, - 125, - 167, - 167, - 83, - 125, - 167, - 208, - 167, - 125, - 125, - 250, - 83, - 208, - 167, - 167, - 208, - 167, - 250, - 208, - 167, - 125, - 291, - 250, - 375, - 125, - 167, - 167, - 166, - 250, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 333, - 125, - 208, - 167, - 125, - 125, - 167, - 208, - 208, - 125, - 500, - 125, - 167, - 208, - 917, - 208, - 209, - 166, - 125, - 209, - 125, - 166, - 125, - 292, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 208, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 250, - 125, - 167, - 208, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 209, - 166, - 125, - 167, - 83, - 125, - 250, - 209, - 125, - 208, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 209, - 166, - 167, - 250, - 167, - 166, - 125, - 209, - 166, - 209, - 166, - 125, - 125, - 167, - 208, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 167, - 250, - 167, - 166, - 167, - 125, - 208, - 167, - 167, - 166, - 209, - 125, - 166, - 209, - 125, - 125, - 250, - 208, - 125, - 167, - 125, - 166, - 209, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 209, - 166, - 167, - 167, - 208, - 167, - 166, - 167, - 167, - 166, - 292, - 125, - 250, - 208, - 209, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 208, - 208, - 125, - 209, - 125, - 166, - 125, - 167, - 208, - 209, - 166, - 125, - 167, - 208, - 209, - 166, - 167, - 125, - 208, - 167, - 167, - 541, - 209, - 166, - 167, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 208, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 208, - 125, - 208, - 167, - 125, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 208, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 209, - 166, - 209, - 166, - 125, - 167, - 125, - 167, - 208, - 250, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 375, - 167, - 208, - 125, - 209, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 15583, - 35334, - 13916, - 125, - 250, - 334, - 208, - 208, - 125, - 292, - 208, - 459, - 125, - 125, - 166, - 125, - 209, - 166, - 125, - 250, - 125, - 167, - 417, - 166, - 125, - 167, - 167, - 125, - 125, - 583, - 125, - 125, - 167, - 166, - 167, - 125, - 375, - 42, - 125, - 166, - 167, - 125, - 167, - 166, - 1292, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 2208, - 10542, - 2167, - 3541, - 250, - 1292, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 83, - 125, - 167, - 83, - 84, - 125, - 166, - 167, - 208, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 875, - 167, - 125, - 166, - 3167, - 333, - 292, - 625, - 917, - 2500, - 666, - 1292, - 167, - 3083, - 792, - 250, - 1083, - 1333, - 167, - 2500, - 125, - 208, - 125, - 417, - 167, - 375, - 458, - 125, - 208, - 167, - 708, - 292, - 250, - 167, - 166, - 334, - 708, - 208, - 792, - 625, - 667, - 416, - 459, - 291, - 167, - 292, - 250, - 125, - 208, - 458, - 209, - 166, - 209, - 166, - 167, - 125, - 208, - 500, - 209, - 291, - 209, - 291, - 542, - 292, - 166, - 709, - 416, - 459, - 125, - 166, - 1000, - 334, - 250, - 125, - 125, - 625, - 166, - 125, - 459, - 125, - 500, - 250, - 166, - 209, - 250, - 250, - 1208, - 708, - 459, - 583, - 333, - 209, - 166, - 209, - 1208, - 167, - 208, - 500, - 167, - 166, - 250, - 167, - 542, - 166, - 375, - 125, - 167, - 542, - 250, - 166, - 1792, - 375, - 250, - 208, - 125, - 292, - 542, - 833, - 667, - 1291, - 375, - 250, - 209, - 416, - 1042, - 167, - 333, - 500, - 208, - 167, - 125, - 292, - 166, - 167, - 417, - 333, - 375, - 125, - 167, - 166, - 292, - 167, - 375, - 208, - 458, - 167, - 333, - 84, - 416, - 167, - 208, - 167, - 250, - 333, - 125, - 167, - 208, - 167, - 375, - 250, - 208, - 125, - 125, - 125, - 334, - 208, - 167, - 291, - 125, - 167, - 500, - 167, - 208, - 333, - 167, - 167, - 125, - 208, - 125, - 208, - 125, - 167, - 125, - 167, - 375, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 167, - 166, - 209, - 125, - 125, - 750, - 125, - 791, - 500, - 209, - 166, - 250, - 209, - 166, - 209, - 166, - 209, - 125, - 166, - 209, - 333, - 1208, - 417, - 167, - 208, - 125, - 167, - 500, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 250, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 250, - 166, - 167, - 125, - 250, - 167, - 208, - 125, - 500, - 375, - 292, - 125, - 125, - 166, - 167, - 83, - 125, - 167, - 333, - 167, - 125, - 208, - 375, - 250, - 209, - 291, - 167, - 208, - 209, - 125, - 208, - 333, - 167, - 250, - 292, - 541, - 709, - 208, - 125, - 125, - 167, - 166, - 209, - 125, - 208, - 125, - 208, - 125, - 125, - 167, - 167, - 208, - 167, - 166, - 125, - 125, - 167, - 208, - 125, - 125, - 209, - 208, - 125, - 167, - 125, - 250, - 125, - 166, - 125, - 84, - 291, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 291, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 250, - 167, - 125, - 125, - 125, - 166, - 125, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 167, - 166, - 125, - 209, - 125, - 166, - 125, - 167, - 167, - 166, - 209, - 166, - 125, - 84, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 208, - 167, - 125, - 208, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 208, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 83, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 166, - 167, - 167, - 416, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 83, - 208, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 167, - 250, - 250, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 208, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 208, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 208, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 166, - 167, - 125, - 125, - 167, - 83, - 83, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 83, - 208, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 167, - 250, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 291, - 84, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 250, - 0, - 84, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 84, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 84, - 83, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 166, - 250, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 250, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 84, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 83, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 375, - 42, - 166, - 167, - 250, - 333, - 42, - 42, - 166, - 167, - 167, - 125, - 166, - 209, - 125, - 250, - 166, - 125, - 167, - 125, - 167, - 208, - 125, - 208, - 167, - 167, - 166, - 167, - 167, - 208, - 167, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 83, - 209, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 208, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 208, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 83, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 417, - 83, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 209, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 208, - 167, - 166, - 125, - 292, - 125, - 167, - 166, - 125, - 209, - 166, - 125, - 125, - 167, - 250, - 167, - 166, - 125, - 125, - 209, - 208, - 125, - 1083, - 84, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 292, - 166, - 167, - 625, - 667, - 208, - 667, - 375, - 625, - 166, - 167, - 833, - 334, - 625, - 166, - 500, - 500, - 542, - 625, - 375, - 500, - 417, - 125, - 333, - 1083, - 292, - 167, - 166, - 334, - 166, - 250, - 375, - 167, - 208, - 209, - 416, - 167, - 333, - 125, - 750, - 167, - 250, - 1083, - 209, - 250, - 208, - 292, - 458, - 500, - 2708, - 459, - 125, - 166, - 584, - 416, - 417, - 583, - 250, - 167, - 250, - 167, - 500, - 333, - 792, - 416, - 542, - 250, - 167, - 250, - 291, - 167, - 167, - 2291, - 459, - 333, - 167, - 250, - 166, - 292, - 333, - 292, - 125, - 458, - 167, - 208, - 334, - 250, - 583, - 458, - 167, - 125, - 125, - 542, - 416, - 459, - 125, - 708, - 208, - 292, - 333, - 417, - 125, - 167, - 1083, - 1208, - 875, - 125, - 1209, - 208, - 333, - 167, - 208, - 209, - 333, - 208, - 167, - 333, - 417, - 292, - 333, - 458, - 250, - 334, - 208, - 208, - 125, - 125, - 250, - 209, - 208, - 167, - 125, - 166, - 417, - 208, - 125, - 250, - 250, - 167, - 417, - 416, - 167, - 208, - 167, - 125, - 292, - 291, - 167, - 167, - 250, - 166, - 167, - 333, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 167, - 208, - 167, - 166, - 125, - 167, - 167, - 208, - 167, - 166, - 209, - 166, - 167, - 875, - 167, - 125, - 333, - 417, - 166, - 334, - 125, - 166, - 167, - 167, - 166, - 167, - 250, - 167, - 125, - 208, - 250, - 208, - 167, - 167, - 166, - 209, - 166, - 209, - 208, - 208, - 209, - 291, - 125, - 334, - 166, - 125, - 167, - 167, - 375, - 125, - 250, - 125, - 166, - 167, - 333, - 167, - 250, - 125, - 292, - 541, - 125, - 209, - 333, - 167, - 250, - 166, - 125, - 292, - 250, - 125, - 167, - 166, - 209, - 125, - 125, - 125, - 208, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 292, - 250, - 292, - 166, - 209, - 166, - 209, - 125, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 292, - 166, - 417, - 167, - 166, - 125, - 84, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 208, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 83, - 167, - 83, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 292, - 125, - 125, - 208, - 125, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 208, - 167, - 125, - 166, - 167, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 208, - 167, - 250, - 125, - 166, - 167, - 167, - 208, - 1750, - 167, - 166, - 167, - 667, - 166, - 125, - 167, - 167, - 166, - 167, - 208, - 167, - 125, - 125, - 167, - 166, - 84, - 125, - 125, - 125, - 166, - 167, - 125, - 208, - 250, - 250, - 84, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 209, - 125, - 250, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 83, - 208, - 459, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 208, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 208, - 292, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 29584, - 1750, - 625, - 375, - 6416, - 1750, - 250, - 334, - 1750, - 2125, - 15750, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 208, - 125, - 208, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 84, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 250, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 84, - 166, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 125, - 208, - 125, - 125, - 208, - 209, - 208, - 417, - 208, - 167, - 125, - 125, - 541, - 167, - 125, - 167, - 166, - 167, - 625, - 292, - 125, - 208, - 208, - 209, - 208, - 125, - 167, - 125, - 208, - 208, - 167, - 167, - 291, - 209, - 166, - 417, - 0, - 333, - 375, - 792, - 292, - 958, - 333, - 209, - 125, - 3958, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 208, - 375, - 208, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 500, - 208, - 125, - 167, - 250, - 166, - 250, - 209, - 166, - 167, - 167, - 166, - 209, - 166, - 1417, - 125, - 167, - 166, - 125, - 167, - 167, - 250, - 250, - 125, - 166, - 125, - 167, - 167, - 208, - 8458, - 12584, - 458, - 1042, - 125, - 166, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 208, - 292, - 125, - 416, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 166, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 84, - 166, - 84, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 208, - 125, - 208, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 83, - 84, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 41, - 84, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 125, - 166, - 42, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 84, - 166, - 42, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 416, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 167, - 125, - 167, - 125, - 208, - 167, - 166, - 125, - 209, - 166, - 209, - 125, - 125, - 208, - 125, - 250, - 208, - 167, - 167, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 667, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 292, - 708, - 458, - 250, - 167, - 167, - 500, - 208, - 292, - 250, - 166, - 209, - 208, - 125, - 167, - 208, - 208, - 125, - 167, - 292, - 166, - 209, - 166, - 209, - 500, - 458, - 417, - 541, - 167, - 2000, - 500, - 167, - 333, - 1083, - 1375, - 459, - 375, - 500, - 291, - 375, - 417, - 125, - 250, - 167, - 125, - 166, - 125, - 250, - 292, - 583, - 167, - 167, - 166, - 167, - 292, - 125, - 291, - 209, - 250, - 208, - 167, - 291, - 209, - 166, - 209, - 166, - 250, - 125, - 209, - 250, - 208, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 208, - 125, - 208, - 125, - 167, - 208, - 167, - 250, - 208, - 250, - 167, - 167, - 250, - 208, - 167, - 166, - 209, - 166, - 167, - 167, - 208, - 292, - 208, - 167, - 250, - 166, - 167, - 167, - 166, - 125, - 334, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 167, - 208, - 125, - 167, - 1625, - 667, - 625, - 291, - 167, - 167, - 250, - 333, - 167, - 83, - 208, - 125, - 167, - 167, - 208, - 208, - 125, - 167, - 167, - 166, - 209, - 166, - 167, - 167, - 166, - 167, - 167, - 250, - 166, - 125, - 167, - 167, - 208, - 250, - 167, - 208, - 208, - 125, - 167, - 167, - 208, - 208, - 167, - 167, - 166, - 167, - 167, - 208, - 167, - 166, - 167, - 167, - 166, - 209, - 208, - 167, - 500, - 125, - 166, - 167, - 375, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 167, - 208, - 167, - 166, - 209, - 125, - 208, - 125, - 167, - 125, - 208, - 167, - 166, - 84, - 166, - 167, - 208, - 167, - 333, - 167, - 125, - 375, - 208, - 459, - 208, - 208, - 125, - 167, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 166, - 125, - 292, - 167, - 166, - 125, - 125, - 209, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 250, - 125, - 208, - 167, - 167, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 208, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 208, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 208, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 84, - 208, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 250, - 125, - 334, - 208, - 167, - 125, - 125, - 125, - 125, - 250, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 83, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 84, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 167, - 125, - 166, - 84, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 208, - 125, - 208, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 83, - 83, - 167, - 125, - 167, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 84, - 208, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 83, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 166, - 209, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 84, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 84, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 83, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 209, - 41, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 42, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 41, - 125, - 84, - 125, - 166, - 125, - 84, - 125, - 125, - 166, - 250, - 125, - 125, - 125, - 167, - 42, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 125, - 125, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 209, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 84, - 125, - 166, - 125, - 209, - 125, - 166, - 125, - 125, - 84, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 209, - 166, - 167, - 125, - 167, - 333, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 83, - 167, - 83, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 208, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 208, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 42, - 167, - 41, - 167, - 125, - 167, - 166, - 84, - 166, - 125, - 84, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 41, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 625, - 42, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 417, - 375, - 792, - 500, - 166, - 167, - 167, - 166, - 167, - 250, - 333, - 209, - 166, - 417, - 167, - 208, - 458, - 375, - 584, - 125, - 166, - 334, - 416, - 125, - 167, - 292, - 166, - 292, - 333, - 167, - 167, - 875, - 166, - 125, - 167, - 208, - 167, - 167, - 208, - 292, - 708, - 458, - 250, - 125, - 750, - 750, - 417, - 500, - 167, - 291, - 209, - 166, - 292, - 833, - 292, - 208, - 167, - 500, - 167, - 208, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 208, - 167, - 292, - 208, - 292, - 166, - 125, - 209, - 166, - 167, - 125, - 208, - 42, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 208, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 166, - 250, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 250, - 83, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 459, - 166, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 167, - 2625, - 47750, - 1333, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 208, - 167, - 333, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 333, - 167, - 83, - 1584, - 208, - 125, - 125, - 125, - 208, - 125, - 167, - 167, - 125, - 916, - 125, - 167, - 417, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 542, - 166, - 6375, - 375, - 3250, - 3125, - 667, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 208, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 209, - 166, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 167, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 167, - 292, - 291, - 167, - 208, - 334, - 291, - 167, - 375, - 167, - 83, - 250, - 167, - 291, - 375, - 125, - 167, - 125, - 125, - 292, - 166, - 209, - 333, - 167, - 166, - 209, - 166, - 209, - 291, - 167, - 125, - 167, - 166, - 292, - 250, - 208, - 167, - 125, - 125, - 167, - 208, - 125, - 125, - 292, - 791, - 334, - 208, - 167, - 208, - 542, - 166, - 209, - 250, - 125, - 125, - 291, - 167, - 167, - 125, - 208, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 208, - 167, - 125, - 167, - 166, - 167, - 125, - 125, - 208, - 167, - 83, - 250, - 292, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 167, - 167, - 208, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 209, - 125, - 208, - 167, - 125, - 125, - 250, - 125, - 208, - 125, - 208, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 333, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 167, - 166, - 125, - 167, - 208, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 83, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 84, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 125, - 125, - 125, - 167, - 208, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 209, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 208, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 209, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 250, - 0, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 83, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 83, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 42, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 250, - 208, - 292, - 166, - 125, - 167, - 250, - 167, - 250, - 208, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 167, - 125, - 125, - 208, - 167, - 125, - 167, - 291, - 84, - 125, - 125, - 166, - 167, - 83, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 166, - 375, - 0, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 583, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 209, - 125, - 291, - 292, - 375, - 792, - 166, - 209, - 208, - 167, - 208, - 167, - 250, - 333, - 208, - 417, - 333, - 334, - 791, - 209, - 208, - 250, - 167, - 375, - 500, - 166, - 1334, - 250, - 375, - 500, - 916, - 125, - 417, - 625, - 417, - 791, - 250, - 167, - 125, - 167, - 250, - 166, - 125, - 167, - 167, - 166, - 84, - 166, - 209, - 125, - 250, - 208, - 333, - 125, - 167, - 167, - 166, - 250, - 334, - 166, - 167, - 208, - 167, - 167, - 166, - 125, - 292, - 167, - 208, - 167, - 250, - 250, - 250, - 166, - 209, - 333, - 292, - 291, - 292, - 458, - 167, - 167, - 166, - 167, - 292, - 208, - 167, - 208, - 208, - 250, - 125, - 209, - 125, - 125, - 125, - 166, - 250, - 292, - 208, - 209, - 208, - 250, - 125, - 167, - 666, - 334, - 208, - 208, - 167, - 167, - 291, - 209, - 166, - 334, - 375, - 166, - 209, - 125, - 166, - 167, - 292, - 166, - 167, - 208, - 167, - 167, - 166, - 209, - 166, - 167, - 167, - 250, - 250, - 208, - 125, - 208, - 459, - 291, - 167, - 208, - 292, - 750, - 125, - 167, - 750, - 375, - 500, - 416, - 167, - 333, - 334, - 166, - 250, - 167, - 208, - 250, - 292, - 417, - 166, - 459, - 208, - 292, - 250, - 333, - 125, - 167, - 208, - 375, - 375, - 167, - 250, - 208, - 417, - 166, - 167, - 167, - 125, - 750, - 166, - 167, - 125, - 167, - 250, - 375, - 166, - 167, - 458, - 125, - 209, - 166, - 292, - 208, - 292, - 167, - 333, - 167, - 166, - 167, - 1000, - 583, - 500, - 209, - 166, - 917, - 542, - 375, - 250, - 166, - 417, - 500, - 167, - 166, - 250, - 167, - 208, - 500, - 375, - 250, - 459, - 583, - 250, - 292, - 416, - 125, - 167, - 167, - 166, - 459, - 250, - 291, - 167, - 167, - 500, - 291, - 292, - 208, - 209, - 208, - 125, - 500, - 125, - 167, - 1166, - 459, - 500, - 208, - 292, - 1041, - 1167, - 792, - 250, - 333, - 167, - 208, - 167, - 291, - 167, - 208, - 167, - 208, - 209, - 125, - 125, - 166, - 125, - 209, - 166, - 125, - 167, - 167, - 166, - 167, - 125, - 125, - 167, - 208, - 167, - 125, - 166, - 250, - 125, - 209, - 208, - 167, - 333, - 167, - 208, - 167, - 416, - 250, - 125, - 167, - 167, - 166, - 250, - 167, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 166, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 208, - 167, - 125, - 166, - 125, - 209, - 166, - 125, - 167, - 208, - 84, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 166, - 209, - 166, - 125, - 125, - 250, - 209, - 125, - 125, - 125, - 125, - 291, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 209, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 208, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 208, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 125, - 125, - 125, - 84, - 125, - 125, - 125, - 125, - 125, - 250, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 208, - 167, - 125, - 125, - 9208, - 6459, - 958, - 1125, - 125, - 583, - 167, - 125, - 125, - 5833, - 1209, - 5250, - 1791, - 7209, - 15708, - 125, - 167, - 166, - 209, - 166, - 167, - 250, - 167, - 125, - 166, - 167, - 167, - 41, - 167, - 167, - 208, - 167, - 166, - 167, - 167, - 125, - 125, - 125, - 83, - 167, - 166, - 125, - 750, - 167, - 167, - 166, - 125, - 125, - 167, - 167, - 333, - 167, - 208, - 125, - 167, - 166, - 125, - 167, - 167, - 125, - 5666, - 167, - 125, - 2292, - 458, - 625, - 167, - 125, - 500, - 166, - 667, - 1000, - 125, - 167, - 166, - 167, - 250, - 208, - 167, - 167, - 208, - 167, - 125, - 166, - 167, - 167, - 166, - 1792, - 208, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 83, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 208, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 208, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 84, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 209, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 250, - 0, - 167, - 167, - 166, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 41, - 84, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 84, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 208, - 83, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 250, - 166, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 250, - 42, - 166, - 125, - 167, - 42, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 41, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 333, - 84, - 83, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 208, - 292, - 167, - 291, - 167, - 167, - 208, - 167, - 500, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 208, - 125, - 209, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 83, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 209, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 209, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 209, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 250, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 208, - 167, - 125, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 84, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 83, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 167, - 166, - 167, - 167, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 41, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 83, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 208, - 167, - 125, - 208, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 84, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 167, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 41, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 209, - 166, - 167, - 83, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 83, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 42, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 125, - 84, - 166, - 84, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 166, - 167, - 125, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 42, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 83, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 166, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 208, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 167, - 167, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 209, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 166, - 167, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 42, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 167, - 166, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 84, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 209, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 250, - 125, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 167, - 167, - 125, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 83, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 209, - 166, - 125, - 125, - 125, - 167, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 167, - 83, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 166, - 125, - 125, - 125, - 125, - 125, - 167, - 42, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 125, - 167, - 167, - 125, - 166, - 125, - 167, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 84, - 166, - 125, - 125, - 167, - 125, - 250, - 125, - 167, - 208, - 167, - 166, - 167, - 125, - 167, - 125, - 208, - 83, - 209, - 125, - 125, - 125, - 125, - 166, - 125, - 125, - 167, - 167, - 166, - 125, - 125, - 167, - 125, - 125, - 125, - 125, - 167, - 125, - 125, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 166, - 125, - 167, - 125, - 167, - 125, - 125, - 166, - 125, - 167, - 167, - 208, - 125, - 250, - 167 - ] -} \ No newline at end of file From 926798dc2f8c252aa5f74ba2880a189d8d3a407f Mon Sep 17 00:00:00 2001 From: David Little Date: Sat, 18 Oct 2025 12:21:22 -0400 Subject: [PATCH 78/79] working linting integration tests Created using spr 1.3.6-beta.1 --- mise.toml | 2 +- notes.md | 11 +- old_format/larkin.toml | 3542 ----------------- old_format/parsing.ts | 459 --- src/extension/keybindings/index.ts | 6 +- src/rust/parsing/src/file.rs | 31 +- .../test-workspace/my_bindings.mk.toml | 35 +- src/test/unit/change-mk-toml.test.ts | 86 +- 8 files changed, 89 insertions(+), 4083 deletions(-) delete mode 100644 old_format/larkin.toml delete mode 100644 old_format/parsing.ts diff --git a/mise.toml b/mise.toml index b8a2ba78..49332d36 100644 --- a/mise.toml +++ b/mise.toml @@ -99,7 +99,7 @@ if ($env.COVERAGE? | default false | into bool) { --coverage-reporter json) } else { (pnpm exec vscode-test --config .vscode-test.mjs --extensionDevelopmentPath . - --version insiders) + --version=insiders) } ''' diff --git a/notes.md b/notes.md index 227b14ba..e442895d 100644 --- a/notes.md +++ b/notes.md @@ -304,10 +304,13 @@ Integration test debugging: of `args.commands`. - [X] args is a non array or table value for a sub command of `runCommands` - [X] non table or string value for an array element of `runCommands` - - [ ] review coverage to verify there aren't additional checks we're missing + - [X] review coverage to verify there aren't additional checks we're missing - [X] test that all error messages show up when expected - [X] make sure a range is always provided - - [ ] integration test for both warnings and errors in type script setup + - [X] integration test for both warnings and errors in type script setup + - [X] get it working in debug + - [X] update tests + - [X] debug unreliable test outcomes - [ ] validate modes to ensure that at least one of them allows the user to type 😬 - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command @@ -338,6 +341,7 @@ Integration test debugging: - [ ] integration tests - [ ] implement `replay`: use the new rust command queues instead of the old state management + - [ ] properly handle user keybindings (have the main keybinding file in memory) - [ ] extraction of markdown docs - [ ] documentation expansion/validation - across all `[[bind]]` values with the same key and mode @@ -351,8 +355,7 @@ Integration test debugging: - [ ] serialization of bindings to settings.json - [ ] create data types to generate warnings/hints for old/unused fields - [ ] test this on the old version of larkin.toml - - [ ] actually replace javascript behavior with rust functions (replace `dod`) - - [ ] replace `setFlag` with `updateDefine` (or something like that) + - [ ] replace `setFlag` with `updateValue` (or something like that) - [ ] CI - [x] setup CI unit tests for rust - [x] setup rust coverage diff --git a/old_format/larkin.toml b/old_format/larkin.toml deleted file mode 100644 index 99652346..00000000 --- a/old_format/larkin.toml +++ /dev/null @@ -1,3542 +0,0 @@ -# --- -# author: David Little -# license: MIT https://github.com/haberdashPI/vscode-master-key/blob/main/LICENSE.md -# --- - -# # Master Keybindings: Larkin - -# Larkin is the default keybinding set that ships with Master Key. It follows in the footsteps of Vim, Kakoune and Helix. This is the version of Larkin that uses a layout dependent keymap. - -# Some key features: - -# - Commands are modal: most actions are available in `normal` mode, while typing occurs in `insert` mode -# - Command are organized around noun-verb ordering: e.g. `w` selects a word, and `d` will then delete it. -# - Selection is sticky: once a selection is created, further commands tend to extend that selection until it is reset (using `v`). However a number of commands are defined to automatically reset the selection (e.g. `mw` creates a new selection around a word). - -# -# These bindings are named after the middle name of my first child (Larkin). - -# -# > ℹ **Info**: If your needs require a layout independent keymap consider changing "Use Layout Independent Bindings" in settings to true. It will transform all bindings to use the layout independent versions of the keys. For example the binding for `w` will be transformed to `[KeyW]`, which corresponds to the location of the letter "W" in the U.S. Keyboard layout. - -# - -#- NOTE: this file is used to generate both keybindings and to generate a markdown file that documents the bindings. When comments are prefixed with a `-` they are ignored in the final markdown output. All other comments will become part of the markdown output. Any [[bind]] entries unbroken by normal, markdown-displayed comments will show up in a table in the markdown output. Make sure that the normal comments do not break up TOML data in a way that means it is invalid TOML. - -[header] -name = "Larkin" -version = "1.0.0" - -requiredExtensions = [ - "dbankier.vscode-quick-select", - "haberdashPI.vscode-select-by-indent", - "haberdashPI.selection-utilities", - "pustelto.bracketeer", - "wmaurer.change-case", - "pkief.markdown-checkbox", - "jack89ita.open-file-from-path", - "koalamer.labeled-bookmarks", - "dnut.rewrap-revived", -] - -[[mode]] -name = "insert" -recordEdits = true - -[[mode]] -name = "normal" -default = true -highlight = "Highlight" -cursorShape = "Block" - -[[mode]] -name = "selectedit" -highlight = "Highlight" -cursorShape = "BlockOutline" - -[define] -select_on = false -around_on = false - -[[kind]] -name = "motion" -description = "These commands move the cursor and/or selections." - -[[kind]] -name = "action" -description = """ -Actions do something with the selected text (e.g. delete it). Unless otherwise noted, in -the absence of a selection, an action will modify an entire line, and a count argument -indicates the number of lines (e.g. 3d deletes this line and the next 3 lines). -""" - -[[kind]] -name = "util" -description = """ -Assorted other commands that aren't motions or actions -""" - -[[define.selectLinesDown]] -command = "selection-utilities.shrinkToActive" - -[[define.selectLinesDown]] -if = "count" -command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true } -computedArgs = { value = "count" } - -[[define.selectLinesDown]] -command = "expandLineSelection" - -[[define.selectLinesUp]] -command = "selection-utilities.shrinkToActive" - -[[define.selectLinesUp]] -if = "count" -command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true } -computedArgs = { value = "count" } - -[[define.selectLinesUp]] -command = "expandLineSelection" - - -[[path]] -id = "modes" -name = "Modes" -default.kind = "util" - -# ## Getting Help - -# There are three kinds of help available in Master Key. - -# 1. The visual documentation shows up in the lower pane and shows the currently available bindings on-top of a keyboard layout. -# 2. The text documentation is what you are reading now. -# 3. The suggestion palette shows a list of the current bindings given the current key binding prefix. - -[[bind]] -path = "util" -key = "shift+;" -name = "suggest" -resetTransient = false -hideInPalette = true -prefixes = [] -mode = ["!capture", "!insert"] -description = """ -show command suggestions within the context of the current mode and keybinding prefix (if any). E.g. `TAB, ⇧;` in `normal` mode will show all `normal` command suggestions that start with `TAB`. -""" -command = "master-key.commandSuggestions" - -[[bind]] -key = "tab /" -name = "text docs" -priority = -1 -mode = "normal" -description = "Show text documentation for keybindings" -command = "master-key.showTextDoc" - -[[bind]] -key = "tab shift+/" -name = "visual doc" -priority = -1 -mode = "normal" -description = "Show visual documentation for keybindings" -command = "master-key.showVisualDoc" - -# The visual keybinding documentation is modified by three additional commands that can be used to determine which modifiers are shown. - -# - `Master Key: Toggle Visual Doc Modifier by frequency`: changes keybinding modifiers from most to least common modifiers across all modifiers defined by the current keybindings. - -# -# There are no keybindings for these commands by default. - -# ## Normal Mode - -# The default mode in Larkin is Normal mode. In this mode, instead of the keys entering text, all keys are commands that modify selections or perform actions on those selections. To exit normal mode you can use `i` to enter `insert` mode, which returns VSCode keybindings to their normal state (see [Simple actions](#simple-actions) for more ways to enter insert mode). - -# While in Normal model you will see a highlighted section with the text "normal" in the lower left hand corner of the status bar. - -[[bind]] -path = "modes" -name = "normal" -description = "Enter normal mode" -foreach.key = ["escape", "ctrl+["] -combinedKey = "escape/ctrl+[" -combinedName = "normal" -combinedDescription = "Enter normal mode" -key = "{key}" -mode = [] -hideInPalette = true -hideInDocs = false -command = "master-key.enterNormal" -when = "!findWidgetVisible" -prefixes = "" - -[[bind]] -path = "modes" -name = "normal" -foreach.key = ["escape", "ctrl+["] -key = "{key}" -hideInPalette = true -hideInDocs = true -when = "suggestWidgetVisible && editorTextFocus && !findWidgetVisible" -command = "runCommands" -args.commands = ["hideSuggestWidget", "master-key.enterNormal"] -mode = [] -prefixes = "" - -#- in "command" like modes (e.g. normal), typing keys without a command defined below should have no effect -[[bind]] -path = "modes" -name = "ignore" -description = "this key does nothing" -foreach.key = [ - '{key: .}', - 'shift+{key: .}', -] #- all keys whose bindings are described by a single character -key = "{key}" -command = "master-key.ignore" -prefixes = "" -mode = ["normal", "selectedit"] -when = "editorTextFocus" -hideInDocs = true -hideInPalette = true -priority = -10 - -[[path]] -id = "edit" -name = "Editor Commands" -when = "editorTextFocus && !findWidgetVisible" -default.mode = "normal" - -[[path]] -id = "edit.count" -name = "count" -default.kind = "count" - -# ## Basic motions - -# These are the most common, simple motions that can be performed in Larkin. - -# Selection behavior uses the following logic: motions that move more than one character generally select the text "under" the motion. If a selection already exists (e.g. from a previous motion) additional motions extend that selection. You can always reset the selection using `v`, and several commands (e.g. `x`) operate on the next character rather than the current selection. - -[[path]] -id = "edit.motion" -name = "Motions" -description = "Commands that move the cursors and/or selections" -default.kind = "motion" - -[[path]] -id = "edit.motion.prim" -name = "Primitive Motions" -description = "Motions fundamental to moving around in the editor." -default.command = "cursorMove" -default.computedArgs.value = "count" -default.computedArgs.select = "editorHasSelection || select_on" - -[[bind]] -path = "edit.motion.prim" -key = "h" -name = "←" -combinedName = "←/→" -combinedKey = "h/l" -combinedDescription = "move left/right" -description = "move left" -args.to = "left" -mode = "normal" - -[[bind]] -path = "edit.motion.prim" -key = "l" -combinedName = "←/→" -name = "→" -description = "move right" -args.to = "right" - -[[bind]] -path = "edit.motion.prim" -key = "j" -name = "↓" -combinedName = "↓/↑" -combinedKey = "j/k" -combinedDescription = "move down/up" -description = "move down" -args.to = "down" -args.by = "wrappedLine" - -[[bind]] -path = "edit.motion.prim" -key = "k" -name = "↑" -description = "move up" -combinedName = "↓/↑" -args.to = "up" -args.by = "wrappedLine" - -[[bind]] -path = "edit.motion.prim" -key = "shift+h" -name = "start" -description = "start of line (alternates between first non-white and first)" -combinedName = "start/end" -combinedKey = "shift+h/shift+l" -combinedDescription = "move to start/end of line" -command = "cursorHomeSelect" - -[[bind]] # we don't use prim because we don't want the defaults -path = "edit.motion" -key = "shift+l" -name = "end" -combinedName = "start/end" -description = "end of line" -command = "cursorMove" -args.to = "wrappedLineEnd" -args.select = true - -[[bind]] -path = "edit.motion.prim" -key = "shift+k" -name = "sel ↑" -combinedName = "sel ↑/↓" -combinedDescription = "select lines up/down" -combinedKey = "shift+k/shift+j" -description = "select lines upwards" -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "up", by = "wrappedLine", select = true } -computedArgs = { value = "count" } - -[[bind.args.commands]] -command = "expandLineSelection" - -[[bind.args.commands]] -command = "selection-utilities.exchangeAnchorActive" - -[[bind]] -path = "edit.motion.prim" -key = "shift+j" -name = "sel ↓" -combinedName = "sel ↑/↓" -description = "select lines downwards" -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "down", by = "wrappedLine", select = true } -computedArgs = { value = "count" } - -[[bind.args.commands]] -command = "expandLineSelection" - -[[bind]] -path = "edit.motion.prim" -key = "ctrl+d" -mode = ["normal", "insert"] -name = "pg ↓" -combinedName = "pg ↓/↑" -combinedKey = "ctrl+d/ctrl+u" -combinedDescription = "move down/up, relative to page size" -description = "move down, relative to page size" -command = "selection-utilities.activePageMove" -args.dir = "down" -computedArgs.count = "(count || 1)/3" -computedArgs.select = "mode == 'normal'" - -[[bind]] -path = "edit.motion.prim" -key = "ctrl+u" -mode = ["normal", "insert"] -name = "pg ↑" -combinedName = "pg ↓/↑" -description = "move up, relative to page size" -command = "selection-utilities.activePageMove" -args.dir = "up" -computedArgs.count = "(count || 1)/3" -computedArgs.select = "mode == 'normal'" - -[[bind]] -path = "edit.motion.prim" -key = "shift+x" -name = "exapand" -description = "expand selections to full lines" -command = "expandLineSelection" -repeat = "count" - -[[path]] -id = "edit.motion.obj" -name = "Motions defined by various regex and syntactical objects" -description = """ -motions that move by a predefined syntactic object (e.g. word, paragraph, etc...) -""" -default.command = "selection-utilities.moveBy" -default.args.boundary = "start" -default.args.select = true - -[[bind]] -path = "edit.motion.obj" -key = "w" -name = "subwrd →" -description = "next subword (camel/snake case)" -combinedName = "subwrd ←/→" -combinedDescription = "next/prev subword (camel/snake case)" -combinedKey = "w/b" -args.unit = "subword" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "b" -name = "subwrd ←" -description = "previous subword (camel/snake case)" -combinedName = "subwrd ←/→" -args.unit = "subword" -computedArgs.value = "-count || -1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+w" -name = "word →" -description = "next word" -combinedName = "word ←/→" -combinedDescription = "next/prev word" -combinedKey = "shift+w/b" -args.unit = "word" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+b" -name = "word ←" -combinedName = "word ←/→" -description = "previous word" -prefixes = [""] -args.unit = "word" -computedArgs.value = "-count || -1" - -[[bind]] -path = "edit.motion.obj" -key = "e" -name = "subwrd end" -description = "next subword (camel/snake case) end" -args.unit = "subword" -args.boundary = "end" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+e" -name = "word end" -description = "next word end" -args.unit = "word" -args.boundary = "end" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+]" -name = "parag. →" -description = "next paragraph" -combinedName = "paragraph →/←" -combinedDescription = "next/previous paragraph" -combinedKey = "shift+]/[" -args.unit = "paragraph" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+[" -name = "parag. ←" -combinedName = "paragraph →/←" -description = "previous paragraph" -args.unit = "paragraph" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.obj" -key = "shift+0" -name = "subsec →" -description = "next subsection" -combinedName = "subsec →/←" -combinedDescription = "next/previous subsection" -combinedKey = "shift+0/9" -args.unit = "subsection" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "shift+9" -name = "subsec ←" -description = "previous subsection" -combinedName = "subsec →/←" -args.unit = "subsection" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.prim" -key = "v" -name = "shrink selection" -combinedName = "shrink/hold selection" -combinedDescription = """ -reduce selections to zero length / make all commands extend the selection -""" -description = """ -reduce all selections to length zero -""" -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "select_on", value = false } }, -] - -[[bind]] -path = "edit.motion.mod" -key = "shift+v" -name = "hold selection" -combinedName = "shrink/hold selection" -description = """ -all motions extend the selection -""" -command = "master-key.setFlag" -args.name = "select_on" -args.value = true - -[[bind]] -path = "edit.action.open_lines" -name = "open, act →" -description = "without selection: open a line below current line and enter insert, with selection: move cursor to start" -key = "o" -combinedName = "open below/above, act →/←" -combinedKey = "o/shift+o" -combinedDescription = """ -without selection: open a line below/above current line and enter insert, with selection: move cursor to end/start -of selection -""" -when = "!editorHasSelection" -command = "runCommands" -args.commands = ["editor.action.insertLineAfter", "master-key.enterInsert"] - -[[bind]] -path = "edit.action.open_lines" -key = "o" -combinedName = "open below/above, act →/←" -when = "editorHasSelection" -command = "selection-utilities.activeAtEnd" - -[[bind]] -path = "edit.action.open_lines" -name = "open blw, act ←" -combinedName = "open below/above, act →/←" -description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" -key = "shift+o" -when = "!editorHasSelection" -command = "runCommands" -args.commands = ["editor.action.insertLineBefore", "master-key.enterInsert"] - -[[bind]] -path = "edit.action.open_lines" -name = "open blw, act ←" -combinedName = "open below/above, act →/←" -description = "without selection: open a line above current line and enter insert, with selection: move cursor to end" -key = "shift+o" -when = "editorHasSelection" -command = "selection-utilities.activeAtStart" - -[[bind]] -path = "edit.motion" -key = "shift+5" -name = "to bracket" -description = "Move to matching bracket" -command = "editor.action.jumpToBracket" - -[[bind]] -path = "edit.motion.prim" -key = '\' -name = "→ sel" -combinedName = "→/← sel" -description = "select *just* the character to the right" -combinedDescription = "select *just* the character to the right" -combinedKey = 'shift+\/\' -mode = ["normal", "selectedit"] -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "right", select = true } -computedArgs = { value = "count" } - -[[bind]] -path = "edit.motion.prim" -key = 'shift+\' -name = "← sel" -combinedName = "→/← sel" -description = "select *just* the character to the left" -mode = ["normal", "selectedit"] -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "left", select = true } -computedArgs = { value = "count" } - -[[path]] -id = "edit.motion.mod" -name = "Modify Motion Effects" -description = "Keys that change how other motions work" -default.kind = "motion" - -[[bind]] -path = "edit.motion.obj" -key = "shift+4" -name = "all" -description = "Select entire document" -command = "editor.action.selectAll" - -[[bind]] -path = "edit.motion" -key = "shift+r" -name = "trim wht" -description = "trim external whitespace" -command = "selection-utilities.trimSelectionWhitespace" - -[[bind]] -path = "edit.motion.obj" -name = "→ num." -description = "Move to next number" -key = "shift+3" -combinedName = "→/← num." -combinedDescription = "Move to next/prev number" -combinedKey = "shift+3/2" -args.unit = "number" -args.selectWhole = true -args.boundary = "both" -computedArgs.value = "(count || 1)" - -[[bind]] -path = "edit.motion.obj" -name = "← num." -description = "Move to next number" -key = "shift+2" -combinedName = "→/← num." -args.unit = "number" -args.selectWhole = true -args.boundary = "both" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion" -name = 'narrow to subword' -description = "Narrow current selection so it starts and stops at a subword (e.g. 'snake' in snake_case)" -key = "z" -command = "selection-utilities.narrowTo" -args.unit = "subident" -args.boundary = "both" - -# ## Repeating Motions - -# Like VIM, the number keys (0-9) can be typed as a prefix to most commands and serve as a `count` -# argument to that command. In most cases this causes the command to be repeated `count` -# times e.g. 2w would select the next two words starting from the current cursor position. - -[[bind]] -path = "edit.count" -foreach.num = ['{key: [0-9]}'] -name = "count {num}" -key = "{num}" -command = "master-key.updateCount" -description = "Add digit {num} to the count argument of a command" -combinedKey = "0-9" -combinedName = "count 0-9" -combinedDescription = "Add digit 1-9 to count argument of a command" -args.value = "{num}" -resetTransient = false -mode = ["!insert", "!capture"] -hideInDocs = true - -# There are several ways to repeat or undo previously entered commands, both actions and motions - -[[path]] -id = "edit.motion.history" -name = "motion history" -description = "Commands that repeat some kind of motion" - -[[bind]] -path = "edit.motion.history" -key = ";" -name = "repeat motion" -description = """ -Repeat the last motion command. Motions usually move the cursor or change the selection. -""" -repeat = "count" -command = "master-key.replayFromHistory" -args.at = """ -commandHistory[i].path.startsWith('edit.motion') && -commandHistory[i].name != 'repeat motion' && -commandHistory[i].name != 'shrink selection' -""" - -[[bind]] -path = "edit.motion.history" -name = "repeat subject" -description = """ -Repeat the subject: a motion command that occurred right before an action. For -instance `w` followed by `d` selects a word and deletes it. The `w` command would be the -last subject until some new action is run after `d`. See also `.` which repeats the last action. -""" -key = "," -command = "master-key.replayFromHistory" -args.at = """ -commandHistory[i].path.startsWith("edit.motion") && -commandHistory[i+1].path.startsWith("edit.action") && -!(commandHistory[i+1].name.startsWith("repeat ") && - commandHistory[i+1].path.startsWith("edit.action.history")) -""" - -[[bind]] -path = "edit.motion.history" -name = "cursor undo" -key = "-" -combinedName = "cursor undo/redo" -combinedKey = "-/shift+-" -command = "cursorUndo" - -[[bind]] -path = "edit.motion.history" -name = "cursor redo" -combinedName = "cursor undo/redo" -key = "shift+-" -command = "cursorRedo" - -[[bind]] -path = "edit.motion.history" -name = "nav ←" -description = "Go back in navigation history (e.g. goto definition)" -combinedName = "nav ←/→" -combinedKey = "n/shift+n" -combinedDescription = "Go back/forward in navigation history" -key = "g n" -command = "workbench.action.navigateBackInNavigationLocations" - -[[bind]] -path = "edit.motion.history" -name = "nav →" -combinedName = "nav ←/→" -description = "Go forward in navigation history (e.g. goto definition)" -key = "g shift+n" -command = "workbench.action.navigateForwardInNavigationLocations" - -[[bind]] -path = "edit.motion.history" -name = "edit hist ←" -description = "Go back in edit history" -key = "g -" -combinedName = "edit ←/→" -combinedKey = "-/shift+-" -combinedDescription = "Go back/forward in edit history" -command = "workbench.action.navigateBackInEditLocations" - -[[bind]] -path = "edit.motion.history" -name = "edit hist →" -description = "Go forward in edit history)" -key = "g shift+-" -combinedName = "edit ←/→" -command = "workbench.action.navigateForwardInEditLocations" - -# ## Search Motions - -# Search motions accept one or more characters and select text up until the given character. Search commands are case insensitive by default. They can serve as very efficient ways to jump to a desired location. E.g. typing `sfod` in normal mode would delete the first three words of the following line of text -# -# > I want some food - -[[path]] -id = "edit.motion.search" -name = "Search Related Motions" -description = "Motions related to searching for text in a document" -default.command = "master-key.search" -default.args.caseSensitive = false -default.args.backwards = false -default.args.selectTillMatch = true -default.args.wrapAround = true - -[[bind]] -path = "edit.motion.search" -key = "/" -name = "search →" -description = "search forwards" -combinedName = "search → (←)" -combinedDescription = "search forwards (backwards)" -combinedKey = "/ (shift+/)" -args.offset = "start" -args.register = "search" - -[[bind]] -path = "edit.motion.search" -key = "shift+/" -name = "search ←" -description = "search backwards" -combinedName = "search → (←)" -args.offset = "start" -args.register = "search" -args.backwards = true - -[[bind]] -path = "edit.motion.search" -key = "n" -name = "→ search" -description = "Go to the next match of the search query" -command = "master-key.nextMatch" -args.register = "search" -computedArgs.repeat = "(count || 1)-1" - -[[bind]] -path = "edit.motion.search" -key = "shift+n" -name = "← search" -description = "Go to the previous match of the search query" -command = "master-key.previousMatch" -args.register = "search" -computedArgs.repeat = "(count || 1)-1" - -[[bind]] -path = "edit.motion.search" -key = "shift+8" -name = "match →" -description = "Next match to object under cursor" -combinedName = "match →/←" -combinedDescription = "Next/previous match to object under cursor" -combinedKey = "shift+8/7" -computedArgs.text = "firstSelectionOrWord" -args.offset = "start" -args.register = "search" - -[[bind]] -path = "edit.motion.search" -key = "shift+7" -name = "match ←" -description = "Previous match to object under cursor" -combinedName = "match →/←" -computedArgs.text = "firstSelectionOrWord" -args.offset = "start" -args.register = "search" -args.backwards = true - -[[bind]] -path = "edit.motion.search" -key = "f" -name = "find char" -description = "Find the next char (include char in selection)" -combinedName = "find char (back)" -combinedDescription = "Find the next (previous) char (include char in selection)" -combinedKey = "f (shift+f)" -args.acceptAfter = 1 -computedArgs.skip = "count-1" -args.offset = "inclusive" - -[[bind]] -path = "edit.motion.search" -key = "shift+f" -name = "find char back" -description = "Find the previous char (include char in selection)" -combinedName = "find char (back)" -args.acceptAfter = 1 -args.offset = "inclusive" -args.backwards = true -computedArgs.skip = "count-1" - -[[bind]] -path = "edit.motion.search" -key = "t" -name = "to char" -description = "Find the next char (exclude char in selection)" -combinedName = "to char (back)" -combinedKey = "t (shift+t)" -combinedDescription = "Find the next/previous char (exclude char in selection)" -args.acceptAfter = 1 -args.offset = "start" -computedArgs.skip = "count-1" - -[[bind]] -path = "edit.motion.search" -key = "shift+t" -name = "to char back" -description = "Find the previous char (exclude char in selection)" -combinedName = "to char (back)" -args.acceptAfter = 1 -args.offset = "end" -args.backwards = true -computedArgs.skip = "count-1" - -[[bind]] -path = "edit.motion.search" -key = "s" -name = "find char pair" -description = "To next character pair" -combinedName = "char pair →/←" -combinedDescription = "To next character pair" -combinedKey = "s/shift+s" -args.acceptAfter = 2 -args.offset = "start" -computedArgs.skip = "count-1" -mode = "normal" - -[[bind]] -path = "edit.motion.search" -key = "shift+s" -name = "char pair back" -description = "To previous character pair" -combinedName = "char pair →/←" -args.acceptAfter = 2 -args.offset = "start" -computedArgs.skip = "count-1" -args.backwards = true - -# ## Goto Commands - -# Goto commands all begin with the mnemonic prefix key `g`. They are additional -# motion commands that compliment the basic motions listed in the previous section. - -[[bind]] -path = "edit.motion" -key = "g" -priority = 1 -name = "goto" -command = "master-key.prefix" -description = """ -Goto commands move the location of the cursor (or the active selection position) forward -or backwards in some direction. -""" - -[[bind]] -path = "edit.motion.prim" -key = "g j" -priority = 1 -name = "unwrp ↓" -combinedName = "unwrap ↓/↑" -combinedKey = "j/k" -combinedDescription = """ -move cursor up/down unwrapped text line; if a single line is wrapped into multiple lines by -the editor, this command skips all such wrapped lines -""" -description = """ -down unwrapped line; if a single line is wrapped into multiple lines by the editor, this -command skips all such wrapped lines -""" -args.to = "down" -args.by = "line" - -[[bind]] -path = "edit.motion.prim" -key = "g k" -priority = 1 -name = "unwrp ↑" -combinedName = "unwrap ↓/↑" -description = "up unwrapped line" -args.to = "up" -args.by = "line" - -[[bind]] -path = "edit.motion.prim" -key = "g shift+k" -priority = 1 -combinedName = "unwrp sel ↑/↓" -combinedDescription = "select unwrapped lines up/down" -combinedKey = "shift+k/j" -name = "unwrp sel ↑" -description = "select unwrapped lines upwards" -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "up", by = "line", select = true } -computedArgs = { value = "count" } - -[[bind.args.commands]] -command = "expandLineSelection" - -[[bind]] -path = "edit.motion.prim" -key = "g shift+j" -priority = 1 -name = "sel ↓" -combinedName = "unwrp sel ↑/↓" -description = "select unwrapped lines downwards" -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorMove" -args = { to = "down", by = "line", select = true } -computedArgs = { value = "count" } - -[[bind.args.commands]] -command = "expandLineSelection" - -[[bind]] -path = "edit.motion.prim" -key = "shift+g" -priority = 1 -name = "doc end" -description = "select to end of document" -combinedName = "doc top/bottom" -combinedDescription = "select to top/bottom of document" -combinedKey = ",/." -command = "cursorBottomSelect" - -[[bind]] -path = "edit.motion.prim" -key = "g g" -priority = 1 -name = "doc start" -description = "select to start (line) of document." -command = "runCommands" -when = "master-key.count > 1" - -[[bind.args.commands]] -command = "cursorTop" - -[[bind.args.commands]] -command = "cursorMove" -args.to = "down" -args.by = "wrappedLine" -computedArgs.value = "count-1" - -[[bind.args.commands]] -command = "revealLine" -args.at = "center" -computedArgs.lineNumber = "count" - -[[bind]] -path = "edit.motion.prim" -key = "g g" -priority = 1 -name = "doc start" -description = "select to start of document" -command = "cursorTopSelect" -when = "master-key.count <= 1" - -[[bind]] -path = "edit.motion.obj" -key = "g w" -priority = 1 -name = "WORD →" -combinedName = "WORD →/←" -combinedDescription = """ -next/prev WORD; e.g. contiguous non-whitespace region -""" -combinedKey = "w/b" -description = "next WORD; e.g. contiguous non-whitespace region" -args.unit = "BigWord" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "g b" -priority = 1 -name = "WORD ←" -combinedName = "WORD →/←" -description = "previous WORD; e.g. contiguous non-whitespace region" -args.unit = "BigWord" -computedArgs.value = "-count || -1" - -[[bind]] -path = "edit.motion.obj" -key = "g e" -priority = 1 -name = "WORD end →" -description = "next WORD end; e.g. contiguous non-whitespace region" -args.unit = "BigWord" -computedArgs.boundary = "around_on ? 'both' : 'end'" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "g 0" -priority = 1 -name = "sec →" -description = "next section" -combinedName = "sec →/←" -combinedDescription = "next/previous section" -combinedKey = "0/9" -args.unit = "section" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.obj" -key = "g 9" -priority = 1 -name = "sec ←" -description = "previous section" -combinedName = "sec →/←" -args.unit = "section" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "window" -name = "goto line" -priority = 1 -description = "goto line command" -key = "g l" -command = "workbench.action.gotoLine" -when = "editorTextFocus" - -[[bind]] -path = "window" -name = "to refs" -priority = 1 -description = "jump to a location where this symbol is referenced" -key = "g r" -command = "editor.action.goToReferences" -when = "editorTextFocus" - -[[bind]] -path = "window" -name = "go to" -priority = 1 -description = "go to the definition of symbol under cursor" -key = "g d" -combinedName = "go to (aside)" -combinedKey = "(shift+)d" -combinedDescription = "go to the definition of symbol (in an editor to the side)" -command = "editor.action.revealDefinition" -when = "editorTextFocus" - -[[bind]] -path = "window" -name = "go to, aside" -priority = 1 -description = "go to the definition of symbol under cursor in an editor to the side" -key = "g shift+d" -combinedName = "go to (aside)" -command = "editor.action.revealDefinitionAside" -when = "editorTextFocus" - -[[bind]] -path = "window" -name = "open" -description = "open the file name under the cursor" -key = "g f" -command = "extension.openFileFromPath" -when = "editorTextFocus" - -[[bind]] -path = "edit.motion" -key = "g c" -name = "cell →" -combinedName = "cell →/←" -command = "runCommands" -args.commands = ["jupyter.gotoNextCellInFile", "jupyter.selectCell"] -description = "previous jupyter notebook cell" - -[[bind]] -path = "edit.motion" -key = "g shift+c" -name = "cell ←" -combinedName = "cell →/←" -description = "previous jupyter notebook cell" -command = "runCommands" -args.commands = ["jupyter.gotoPrevCellInFile", "jupyter.selectCell"] - -# ## Match Commands - -# Match commands select some syntactical region of text, e.g. in or around parenthesis, brackets, indent level etc... Where the `g` prefixed commands move forward or backward, these commands move both the start and the end of the selection away from the active cursor position. Repeating the command moves to the next (or previous) match, depending on the command. - -# If you accidentally select `around` instead of `in`, you can revise your selection using `R` to narrow to non-white space or `z` to narrow to a subword (e.g. excludes `_`) - -[[path]] -id = "edit.motion.match" -name = "Matching Motions" -description = "Motions that match some range of characters" - -[[path]] -id = "edit.motion.match.obj" -name = "Matching Object Motions" -description = "Motions that match some range of characters by predefined regex" -default.command = "selection-utilities.moveBy" -default.kind = "motion" -default.args.selectWhole = true -default.args.boundary = "start" - -[[bind]] -path = "edit.motion.match" -key = "m" -name = "match" -description = """ -Find the closest character range matching a specified object. -""" -kind = "motion" -command = "master-key.prefix" - -[[bind]] -path = "edit.motion.match" -key = "m m" -prefixes = [""] -name = "smart expand" -description = "Use VSCode's built-in smart expansion command" -command = "editor.action.smartSelect.expand" - -[[bind]] -path = "edit.motion.match.obj" -key = "m w" -name = "around subwrd →" -description = "(camel/snake case)" -combinedName = "around subwrd ←/→" -combinedDescription = "(camel/snake case)" -combinedKey = "w/b" -args.unit = "subword" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m b" -name = "around subwrd ←" -description = "(camel/snake case)" -combinedName = "around subwrd ←/→" -args.unit = "subword" -computedArgs.value = "-count || -1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+w" -name = "ard word →" -combinedName = "around word →/←" -combinedKey = "shift+w/b" -args.unit = "word" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+b" -name = "ard word ←" -combinedName = "around word →/←" -prefixes = [""] -args.unit = "word" -computedArgs.value = "-count || -1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m e" -name = "in subwrd" -combinedName = "in → subword/word" -combinedKey = "e/shift+e" -args.unit = "subident" -args.boundary = "both" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+e" -name = "in word" -combinedName = "in → subword/word" -args.unit = "word" -args.boundary = "both" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m p" -name = "in parag. →" -combinedName = "in paragraph →/←" -combinedKey = "p/o" -args.boundary = "both" -args.unit = "paragraph" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m o" -name = "in parag. ←" -combinedName = "in paragraph →/←" -args.unit = "paragraph" -args.boundary = "both" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+p" -name = "arn parag. →" -combinedName = "around paragraph →/←" -combinedKey = "shift+p/shift+o" -args.unit = "paragraph" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+o" -name = "arn parag. ←" -combinedName = "around paragraph →/←" -args.unit = "paragraph" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match.obj" -key = "m 0" -name = "arn subsec →" -combinedName = "around subsection →/←" -combinedKey = "0/shift+0" -args.unit = "subsection" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+0" -name = "arn subsec ←" -combinedName = "around subsection →/←" -args.unit = "subsection" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match.obj" -key = "m 9" -name = "in subsec →" -combinedName = "in subsection →/←" -combinedKey = "9/shift+9" -args.unit = "subsection" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m shift+9" -name = "in subsec ←" -combinedName = "in subsection →/←" -args.unit = "subsection" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match" -key = "m g" -name = "other..." -description = "additional objects to match..." -command = "master-key.prefix" - -[[bind]] -path = "edit.motion.match.obj" -key = "m g 0" -name = "section →" -combinedName = "section →/←" -combinedKey = "0/9" -args.unit = "section" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m g 9" -name = "section ←" -combinedName = "section →/←" -args.unit = "section" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match.obj" -key = "m g w" -name = "around WORD →" -combinedName = "around WORD →/←" -combinedKey = "w/b" -args.unit = "BigWord" -computedArgs.value = "count || 1" - -[[bind]] -path = "edit.motion.match.obj" -key = "m g b" -name = "around WORD ←" -combinedName = "around WORD →/←" -args.unit = "BigWord" -computedArgs.value = "-(count || 1)" - -[[bind]] -path = "edit.motion.match.obj" -key = "m g e" -name = "in WORD" -args.unit = "BigWord" -args.boundary = "both" -computedArgs.value = "count || 1" - -[[path]] -id = "edit.motion.match.syntax" -name = "Motions around syntactic objects (e.g. parentheses and quotes)" -description = """ -selection commands that move by a predefined syntactic object like brackets and quotes -""" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m [" -name = "in parens" -combinedName = "in/arnd parens" -combinedKey = "[/shift+[" -combinedDescription = """ -expand inside/around parens/brackets/braces and their contents; repeated calls to this command -will seek out larger and larger scopes -""" -description = """ -expand inside parens/brackets/braces and their contents; repeated calls to this command -will seek out larger and larger scopes -""" -command = "selection-utilities.expandWithinBrackets" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m shift+[" -name = "arnd parens" -combinedName = "in/arnd parens" -description = """ -expand inside parens/brackets/braces and their contents; repeated calls to this command -will seek out larger and larger scopes -""" -command = "selection-utilities.expandAroundBrackets" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m '" -name = "in quotes" -description = """ -select within current quotes; repeated calls to this command -will seek out larger and larger scopes -""" -combinedName = "in/arnd quotes" -combinedKey = "'/shift+'" -combinedDescription = """ -select within/around current quotes; repeated calls to this command -will seek out larger and larger scopes -""" -command = "bracketeer.selectQuotesContent" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m shift+'" -name = "around quotes" -combinedName = "in/arnd quotes" -description = """ -select around current quotes; repeated calls to this command -will seek out larger and larger scopes -""" -command = "runCommands" -args.commands = ["bracketeer.selectQuotesContent", "bracketeer.selectQuotesContent"] - -[[bind]] -path = "edit.motion.match.syntax" -key = "m shift+." -name = "in <>" -description = "text inside angle brackets" -combinedName = "in <> / in ><" -combinedKey = "shift+. / shift+," -combinedDescription = "text inside angle brackets / pairs (e.g. text in text)" -command = "extension.selectAngleBrackets" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m shift+," -name = "in ><" -combinedName = "in <> / in ><" -description = "text inside tag pairs (e.g. text)" -command = "extension.selectInTag" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m i" -name = "in indent" -description = "all text at the same indentation level" -combinedName = "in/arnd" -combinedKey = "space/shift+space" -combinedDescription = """ -all text at the same indentation level / all indentation along with the line above and -below this (ala c-like syntax) -""" -command = "vscode-select-by-indent.select-inner" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m shift+i" -name = "arnd indent" -description = """ -all text at the same indentation level along with the line above and below -this (ala c-like syntax) -""" -combinedName = "in/arnd" -command = "vscode-select-by-indent.select-outer" - -[[bind]] -path = "edit.motion.match.syntax" -key = "m g i" -name = "indent+top" -description = """ -all text at the same indentation level and the line just above it (ala python syntax) -""" -combinedName = "in/arnd" -command = "vscode-select-by-indent.select-outer-top-only" - -[[path]] -id = "edit.motion.match.cell" -name = "Matching Object Motions" -description = "Motions that match some range of characters by predefined regex" - -[[bind]] -path = "edit.motion.match.cell" -name = "in cell" -description = "select text within a cell (ala jupyter)" -key = "m c" -command = "jupyter.selectCell" - -[[path]] -id = "edit.motion.searchpair" -name = "Search pairs" -description = "Find text that falls between pairs of characters" - -[[bind]] -path = "edit.motion.searchpair" -name = "between pair" -combinedDescription = """ -Select between pairs of the same N characters (t) or distinct sets of N -characters (s), where N is the count. Examples: -2mt'' would search for a string between `''` and `''`. -2ms,,.. would search for a string between `,,` and `..`. -""" -key = "m t" -command = "runCommands" -combinedName = "between pair/two" -combinedKey = "t/s" -description = """ -Select between pairs of the same N characters, where N is the count. -Example: 2mt'' would search for a string between '' and ''. -""" - -[[bind.args.commands]] -command = "master-key.captureKeys" -computedArgs.acceptAfter = "count || 1" - -[[bind.args.commands]] -command = "selection-utilities.selectBetween" -computedArgs.str = "captured" -args.inclusive = false - -[[bind]] -path = "edit.motion.searchpair" -name = "between two" -description = """ -Select between two different sets of N characters, where N is the count e.g. -2ms,,.. would search for a string between ,, and .. -""" -key = "m s" -combinedName = "between pair/two" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.captureKeys" -computedArgs.acceptAfter = "2*(count || 1)" - -[[bind.args.commands]] -command = "selection-utilities.selectBetween" -computedArgs.between.from = "captured.slice(0, captured.length/2)" -computedArgs.between.to = "captured.slice(captured.length/2)" -args.inclusive = false - -# ## Simple Actions - -# These are the most common, basic actions available in Larkin that can be used -# to edit text in relation to the current selection. - -[[path]] -id = "edit.action" -name = "Actions" -description = "Commands that modify the document or UI" -default.kind = "action" -default.mode = "normal" - -[[path]] -id = "edit.action.basic" -name = "Basic Actions" -description = "Essential actions required to edit text" - -[[bind]] -path = "edit.action.basic" -#- TODO: add documentation to these basic editor keys -key = "i" -name = "insert" -description = "Switch to insert mode (right before character)" -command = "runCommands" -args.commands = ["selection-utilities.shrinkToActive", "master-key.enterInsert"] -mode = ["normal", "selectedit", "syminsert"] - -[[bind]] -path = "edit.action.basic" -key = "a" -name = "append" -description = "insert after cursor" -mode = ["normal", "selectedit", "syminsert"] -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - "cursorRight", - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "shift+i" -name = "insert start" -mode = ["normal", "selectedit", "syminsert"] -command = "runCommands" -args.commands = [ - { command = "cursorMove", args = { to = "wrappedLineFirstNonWhitespaceCharacter", select = false } }, - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "shift+a" -name = "insert end" -mode = ["normal", "selectedit", "syminsert"] -command = "runCommands" -args.commands = [ - { command = "cursorMove", args = { to = "wrappedLineEnd", select = false } }, - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "c" -name = "change" -description = """ -Without a count: change selected region of text. With a count: -change up to `count` lines. -""" -when = "editorHasMultilineSelection" -command = "runCommands" -args.commands = ["deleteRight", "editor.action.insertLineBefore", "master-key.enterInsert"] - -[[bind]] -path = "edit.action.basic" -key = "c" -when = "!editorHasMultilineSelection && editorHasSelection" -command = "runCommands" -args.commands = ["deleteRight", "master-key.enterInsert"] - -[[bind]] -path = "edit.action.basic" -key = "c" -when = "!editorHasSelection && master-key.count <= 1" -command = "runCommands" -args.commands = [ - "expandLineSelection", - "deleteRight", - "editor.action.insertLineBefore", - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "c" -when = "!editorHasSelection && master-key.count > 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "deleteRight", - "editor.action.insertLineBefore", - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "shift+c" -name = "change to/back" -description = """Without a count: change from current char to end of line. With a count: -change the previous `count` lines. -""" -mode = "normal" -when = "master-key.count <= 1" -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - "deleteAllRight", - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "shift+c" -mode = ["normal", "selectedit"] -when = "master-key.count > 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesUp" }, - "deleteRight", - "editor.action.insertLineBefore", - "master-key.enterInsert", -] - -[[bind]] -path = "edit.action.basic" -key = "x" -mode = "normal" -name = "delete char" -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "right", select = true }, computedArgs = { value = "count" } }, - "editor.action.clipboardCutAction", -] - -[[bind]] -path = "edit.action.basic" -key = "r" -name = "replace char" -description = "replace the character under the cursor" -command = "master-key.replaceChar" - -[[bind]] -path = "edit.action.basic" -key = "ctrl+i" -name = "insert char" -mode = ["normal", "selectedit"] -description = "insert a character in front of the cursor" -command = "master-key.insertChar" - -[[path]] -id = "edit.action.clipboard" -name = "Clipboard Operations" -description = "Operations that manipulate the clipboard in some way." - -[[bind]] -path = "edit.action.clipboard" -key = "p" -name = "paste after" -description = "Paste clipboard after the cursor/selection" -combinedName = "paste before/after/in" -combinedDescription = "Paste clipboard before/after/at the cursor/selection" -combinedKey = "p/shift+p/ctrl+p" -when = "editorHasSelection" -command = "runCommands" -args.commands = [ - "selection-utilities.activeAtEnd", - "selection-utilities.shrinkToActive", - "editor.action.clipboardPasteAction", -] - -[[bind]] -path = "edit.action.clipboard" -key = "p" -name = "paste after" -combinedName = "paste before/after/in" -when = "!editorHasSelection" -command = "runCommands" -args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] - -[[bind]] -path = "edit.action.clipboard" -key = "ctrl+p" -when = "!suggestWidgetVisible" -mode = ["normal", "insert"] -name = "paste in" -combinedName = "paste before/after/in" -description = "Paste clipboard at location" -command = "editor.action.clipboardPasteAction" - -[[bind]] -path = "edit.action.clipboard" -key = "shift+p" -name = "paste before" -combinedName = "paste before/after" -description = "Paste before the cursor/selection" -when = "editorHasSelection" -command = "runCommands" -args.commands = [ - "selection-utilities.activeAtStart", - "selection-utilities.shrinkToActive", - "editor.action.clipboardPasteAction", -] - -[[bind]] -path = "edit.action.clipboard" -key = "shift+p" -combinedName = "paste before/after" -when = "!editorHasSelection" -command = "runCommands" -args.commands = ["cursorRight", "editor.action.clipboardPasteAction"] - -[[bind]] -path = "edit.action.history" -name = "repeat action" -description = """ -Repeat the last action command. Actions usually modify the text of a document in one way or -another. (But, e.g. sending text to the REPL is also considered an editor action). -See also `,` which repeats the last subject. -""" -key = "." -command = "runCommands" -repeat = "count" - -[[bind.args.commands]] -command = "master-key.replayFromHistory" -#- we can repeat any action but history-related actions; we make an exception for replaying macros, which can be repeated -args.at = """ -commandHistory[i].path.startsWith('edit.action') && -(!commandHistory[i].path.startsWith('edit.action.history') || - commandHistory[i].name == 'replay') -""" - -[[bind.args.commands]] -command = "master-key.enterNormal" - -[[bind]] -path = "edit.action.history" -name = "undo" -key = "u" -command = "runCommands" -args.commands = ["undo", "selection-utilities.shrinkToActive"] - -[[bind]] -path = "edit.action.history" -name = "redo" -key = "shift+u" -command = "runCommands" -args.commands = ["redo", "selection-utilities.shrinkToActive"] - -[[bind]] -path = "edit.action.basic" -name = 'toggle check' -description = "Toggle a markdown checkbox" -key = "shift+6" -command = "markdown-checkbox.markCheckbox" - -[[bind]] -path = "edit.action.clipboard" -key = "d" -name = "delete" -description = """ -Without a count: delete selected text (and store to clipboard). With a -count, delete up to the next `count` lines and store to clipboard. -""" -when = "!editorHasSelection" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.clipboardCutAction", - { command = "master-key.setMode", args = { value = "normal" } }, -] - -[[bind]] -path = "edit.action.clipboard" -key = "d" -when = "editorHasSelection" -command = "runCommands" -args.commands = [ - "editor.action.clipboardCutAction", - { command = "master-key.setMode", args = { value = "normal" } }, -] - -[[bind]] -path = "edit.action.clipboard" -key = "shift+d" -mode = "normal" -name = "without count: Delete from cursor to end of line; with count: Delete from current line up `count` number of keys." -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "wrappedLineEnd", select = true } }, - "editor.action.clipboardCutAction", -] - -[[bind]] -path = "edit.action.clipboard" -key = "shift+d" -mode = "normal" -when = "master-key.count > 1" -command = "runCommands" -args.commands = [{ defined = "selectLinesUp" }, "deleteRight"] - -[[bind]] -path = "edit.action.clipboard" -key = "y" -name = "copy" -description = "copy selected text to clipboard" -command = "runCommands" -args.commands = ["editor.action.clipboardCopyAction", "selection-utilities.shrinkToActive"] - -[[bind]] -path = "edit.action.clipboard" -key = "y" -when = "master-key.count > 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive", -] - -[[bind]] -path = "edit.action.clipboard" -key = "shift+y" -name = "copy (eol/up)" -description = "without a count: copy to end of line; with a count: copy this and the previous N lines" -when = "master-key.count <= 1" -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - { command = "cursorMove", args = { to = "wrappedLineEnd", select = true } }, - "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive", -] - -[[bind]] -path = "edit.action.clipboard" -key = "shift+y" -when = "master-key.count > 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesUp" }, - "editor.action.clipboardCopyAction", - "selection-utilities.shrinkToActive", -] - -[[path]] -id = "edit.action.open_lines" -name = "Line opening actions" -description = """ -These commands provides several ways of adding lines above or below the current line -""" - -[[path]] -id = "edit.action.indent" -name = "Indentation" -description = """ -Operations that affect line indentation -""" - -[[bind]] -path = "edit.action.indent" -key = "shift+." -name = "indent" -description = "Indent lines" -command = "editor.action.indentLines" - -[[bind]] -path = "edit.action.indent" -key = "shift+." -name = "indent" -description = "Indent lines" -when = "master-key.count >= 1" -command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, "editor.action.indentLines"] - -[[bind]] -path = "edit.action.indent" -key = "shift+," -name = "deindent" -when = "master-key.count < 1" -description = "De-indent lines" -command = "editor.action.outdentLines" - -[[bind]] -path = "edit.action.indent" -key = "shift+," -name = "deindent" -when = "master-key.count >= 1" -description = "Deindent lines" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.outdentLines", - "selection-utilities.shrinkToActive", -] - -[[path]] -id = "edit.action.history" -name = "History Commands" -description = "Commands that interact with edit or cursor history." - -# ## Number actions - -# These commands modify or enter numbers in some way. - -[[path]] -id = "edit.action.numbers" -name = "Number Editing" -description = "Commands that modify one or more numbers" - -[[bind]] -path = "edit.action.numbers" -name = 'inc #' -description = "Increment a number by 1" -key = "=" -command = "selection-utilities.incrementNumber" - -[[bind]] -path = "edit.action.numbers" -name = 'dec #' -description = "Decrement a number by 1 " -key = "shift+=" -command = "selection-utilities.decrementNumber" - -# ## Captilization - -# These modify the capitalization of letters in some way. - -[[path]] -id = "edit.action.capitals" -name = "Capitlization Actions" -description = "Actions that change how words are capitalized" -default.mode = ["normal", "selectedit"] - -[[bind]] -path = "edit.action.capitals" -name = 'camel' -description = "Swap style to lower camel case (`camelCase`)" -key = "` c" -command = "extension.changeCase.camel" - -[[bind]] -path = "edit.action.capitals" -name = 'constant' -description = "Swap style to constant (`IS_CONSTANT`)" -key = "` shift+u" -command = "extension.changeCase.constant" - -[[bind]] -path = "edit.action.capitals" -name = 'dot' -description = "Swap style to dot case (`dot.case`)" -key = "` ." -command = "extension.changeCase.dot" - -[[bind]] -path = "edit.action.capitals" -name = 'kebab' -description = "Swap style to kebab case (`kebab-case`)" -key = "` -" -command = "extension.changeCase.kebab" - -[[bind]] -path = "edit.action.capitals" -name = 'all lower' -description = "Swap all to lower case" -key = "` shift+l" -command = "extension.changeCase.lower" - -[[bind]] -path = "edit.action.capitals" -name = 'first lower' -description = "Swap first letter to lower case" -key = "` l" -command = "extension.changeCase.lowerFirst" - -[[bind]] -path = "edit.action.capitals" -name = 'spaces' -description = "Swap to spaces (`camelCase` -> `camel case`)" -key = "` space" -command = "extension.changeCase.no" - -[[bind]] -path = "edit.action.capitals" -name = 'Camel' -description = "Swap to upper camel case (`CamelCase`)" -key = "` shift+c" -command = "extension.changeCase.pascal" - -[[bind]] -path = "edit.action.capitals" -name = 'path' -description = "Swap to 'path' case (`path/case`)" -key = "` /" -command = "extension.changeCase.path" - -[[bind]] -path = "edit.action.capitals" -name = 'snake' -description = "Swap to snake case (`snake_case`)" -key = "` shift+-" -command = "extension.changeCase.snake" - -[[bind]] -path = "edit.action.capitals" -name = 'swap' -description = "Swap upper and lower case letters" -key = "` s" -command = "extension.changeCase.swap" - -[[bind]] -path = "edit.action.capitals" -name = 'title' -description = "Swap to title case (all words have first upper case letter)" -key = "` t" -command = "extension.changeCase.title" - -[[bind]] -path = "edit.action.capitals" -name = 'all upper' -description = "Swap to use all upper case letters" -key = "` shift+y" -command = "extension.changeCase.upper" - -[[bind]] -path = "edit.action.capitals" -name = 'first upper' -description = "Swap first character to upper case" -key = "` u" -command = "extension.changeCase.upperFirst" - -# ## "Do" Actions - -# These keys are all organized under the `space` key and they "do" something. These are generally more elaborate editing operations in the current editor pane. - -[[path]] -id = "edit.action.do" -name = "'Do' actions" -description = "Additional actions organized under the `'` (or 'do') prefix." -default.mode = "normal" - -[[bind]] -path = "edit.action.do" -name = "do" -key = "space" -description = "additional actions, mostly for modifying specific syntactic formats" -command = "master-key.prefix" - -[[bind]] -path = "edit.action.do" -name = "paste after line" -combinedName = "paste after/before line" -combinedKey = "p/shift+p" -description = "Paste text after current line" -priority = 2 -key = "space p" -command = "runCommands" -args.commands = [ - "expandLineSelection", - "selection-utilities.activeAtEnd", - "selection-utilities.shrinkToActive", - "editor.action.clipboardPasteAction", -] - -[[bind]] -path = "edit.action.do" -priority = 2 -name = "paste before line" -combinedName = "paste after/before line" -description = "Paste text before current line" -key = "space shift+p" -command = "runCommands" -args.commands = [ - "expandLineSelection", - "selection-utilities.activeAtStart", - "selection-utilities.shrinkToActive", - "editor.action.clipboardPasteAction", -] - -[[bind]] -path = "edit.action.do" -priority = 2 -name = "add line below" -combinedName = "add line below/above" -combinedDescription = "open a line below/above current line" -combinedKey = "o/shift+o" -description = "open a line below current line" -key = "space o" -command = "editor.action.insertLineAfter" - -[[bind]] -path = "edit.action.do" -name = "add line above" -priority = 2 -combinedName = "add line below/above" -description = "open a line above current line" -key = "space shift+o" -command = "editor.action.insertLineBefore" - -[[bind]] -path = "edit.action.do" -name = 'sym insert' -description = "Insert a character pair around a character" -priority = 1 -key = "space i" -combinedName = "sym insert (mode)" -combinedDescription = "Insert characters around pair (switching to syminster mode until hitting again)" -combinedKey = "i/shift+i" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.captureKeys" -args.acceptAfter = 1 - -[[bind.args.commands]] -command = "selection-utilities.insertAround" -computedArgs.before = "braces[captured].before || captured" -computedArgs.after = "braces[captured].after || captured" -args.followCursor = true - -[[bind]] -path = "edit.action.do" -name = 'trim white' -description = "Delete all external whitespace (left and right edges)" -key = "space shift+-" -command = "selection-utilities.trimWhitespace" - -[[bind]] -path = "edit.action.do" -key = "space w" -name = "wrap p" -combinedName = "wrap/join lines" -description = "wrap paragraph text, preserving commenting" -combinedDescription = "wrap paragraph text, preserving commenting / join lines together" -combinedKey = "w/j" -command = "rewrap.rewrapComment" - -[[bind]] -path = "edit.action.basic" -name = 'join' -combinedName = "wrap/join lines" -description = "Remove newline between current and next line" -key = "space j" -mode = ["normal", "selectedit"] -when = "!editorHasSelection" -command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, 'editor.action.joinLines'] - -[[bind]] -path = "edit.action.basic" -combinedName = "wrap/join lines" -name = 'join' -description = "Remove newline between current and next line" -mode = ["normal", "selectedit"] -key = "space j" -command = "editor.action.joinLines" - -[[bind]] -path = "edit.action.do" -key = "space f" -name = "format" -combinedName = "format / format document" -when = "master-key.count < 1" -command = "editor.action.formatSelection" - -[[bind]] -path = "edit.action.do" -key = "space f" -combinedName = "format / format document" -combinedKey = "f/shift+f" -combinedDescription = "Format selection / document" -name = "format" -description = "Format sel" -when = "master-key.count >= 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.formatSelection", - "selection-utilities.shrinkToActive", -] - -[[bind]] -path = "edit.action.do" -key = "space shift+f" -name = "format doc" -combinedName = "format / format document" -command = "editor.action.formatDocument" - -[[path]] -id = "edit.action.brackets" -name = 'Bracket/Quote Editing' -description = "Commands that edit two matching brackets or quotes." - -[[bind]] -path = "edit.action.do" -name = 'parens' -description = "actions related to various brackets (`[`, `(`, `{`)" -key = "space [" -command = "master-key.prefix" - -[[bind]] -path = "edit.action.do" -name = 'remove' -description = "Removes surrounding pairs" -key = "space [ d" -command = "bracketeer.removeBrackets" - -[[bind]] -path = "edit.action.do" -name = 'parens/brackets' -description = "Swap between `[`, `(` and `{`" -key = "space [ s" -command = "bracketeer.swapBrackets" - -[[bind]] -path = "edit.action.do" -name = 'quotes' -description = "Actions related to quotes" -key = "space '" -command = "master-key.prefix" - -[[bind]] -path = "edit.action.do" -name = 'remove' -description = "Removes quotes (', \" or `)" -key = "space ' d" -command = "bracketeer.removeQuotes" - -[[bind]] -path = "edit.action.do" -name = 'swap' -description = "Swap quotes (', \" or `)" -key = "space ' s" -command = "bracketeer.swapQuotes" - -[[path]] -id = "edit.action.comment" -name = "Comments" -description = """ -Operations that modify comments -""" - -[[bind]] -path = "edit.action.do" -key = "space /" -combinedName = "(block) comment" -when = "master-key.count < 1" -command = "editor.action.commentLine" - -[[bind]] -path = "edit.action.do" -key = "space /" -name = "comment lines" -combinedName = "(block) comment" -combinedDescription = "Toggle (block) comment" -combinedKey = "(shift+)/" -description = "select next comment" -when = "master-key.count >= 1" -command = "runCommands" -args.commands = [{ defined = "selectLinesDown" }, "editor.action.commentLine"] - -[[bind]] -path = "edit.action.do" -key = "space shift+/" -when = "master-key.count < 1" -combinedName = "(block) comment" -command = "editor.action.blockComment" - -[[bind]] -path = "edit.action.do" -key = "space shift+/" -name = "block comment lines" -combinedName = "(block) comment" -description = "select previous comment" -when = "master-key.count >= 1" -command = "runCommands" -args.commands = [ - { defined = "selectLinesDown" }, - "editor.action.blockComment", - "selection-utilities.shrinkToActive", -] - -[[bind]] -path = "edit.action.do" -name = 'inc all #' -combinedName = "inc/dec all #" -combinedDescription = "Increment/decrement selected numbers; increment/decrement increases per selection" -combinedKey = "=/shift+=" -description = "Increment selected numbers; increment increases per selection" -key = "space =" -command = "selection-utilities.incrementNumberPerSelection" - -[[bind]] -path = "edit.action.do" -name = 'dec all #' -combinedName = "inc/dec all #" -description = "Decrement selected numbers; decrement increases per selection" -key = "space shift+=" -command = "selection-utilities.decrementNumberPerSelection" - -[[bind]] -path = "edit.action.do" -name = 'nb cell' -description = "Actions related to notebook cells" -key = "space c" -command = "master-key.prefix" - -[[bind]] -path = "edit.action.do" -key = "space c i" -when = "editorLangId == 'quarto'" -command = "quarto.insertCodeCell" -name = "insert cell" -description = "insert a new cell in a notebook" - -[[bind]] -path = "edit.action.do" -key = "space c s" -when = "editorLangId != 'quarto'" -command = "jupyter.selectCell" - -[[bind]] -path = "edit.action.basic" -key = "space ." -name = 'sent. lines' -description = "Split paragraph into one line per sentence" -mode = "normal" -command = "runCommands" - -[[bind.args.commands]] -command = "selection-utilities.moveBy" -args.unit = "paragraph" -args.boundary = "both" -args.selectWhole = true - -[[bind.args.commands]] -command = "editor.action.joinLines" - -[[bind.args.commands]] -command = "selection-utilities.createBy" -args.text = "." - -[[bind.args.commands]] -command = "selection-utilities.shrinkToActive" - -[[bind.args.commands]] -command = "cursorRight" - -[[bind.args.commands]] -command = "type" -args.text = "\n" - -[[bind.args.commands]] -command = "selection-utilities.cancelSelection" - -# ## Repeat actions - -# These commands interact with the history of previously typed commands to repeat some sequence of commands. They can record any edits, and any commands that are issued through master key bindings. Commands that are not part of this binding file (e.g. a standard call to Cmd/Ctrl+V to paste) will not be recorded. You can copy your non-master-key bindings over to master key (so that they will be recorded) by [customizing your bindings](#customized-bindings) and using `Import Default Bindings` and `Import User Bindings` to allow all of the default and user bindings stored in VSCOde's normal keybinding files to be recorded by master key. (You will have to remove your original user bindings from the VSCOde `keybinding.json` file manually) - -[[bind]] -path = "edit.action.history" -name = "record" -description = "Start/stop recording Master Key commands" -key = "shift+q" -when = "!master-key.record" -command = "master-key.record" -args.on = true - -[[bind]] -path = "edit.action.history" -name = "record" -description = """ -Start/stop recording key presses defined by Master Key pushing it to the -top of the `history` stack once recording finishes." -""" -key = "shift+q" -when = "master-key.record" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.record" -args.on = false - -[[bind.args.commands]] -command = "master-key.pushHistoryToStack" -args.range.from = 'commandHistory[i-1].name === "record"' -args.range.to = "i" - -[[bind]] -path = "edit.action.history" -name = "replay" -description = """ -Replay the Master Key command sequence at the top of the `history` stack. Specifying -a count requests the Nth most recent item on this stack. -""" -key = "q q" -command = "master-key.replayFromStack" -computedArgs.index = "count" - -[[bind]] -path = "edit.action.history" -name = "store macro" -description = """ -Stores the top of the `history` stack into a named register. Specifying a count stores the -Nth most recent item on this stack. -""" -key = "q s" -command = "master-key.storeNamed" -args.description = "Save Macro" -args.name = "macro" -args.contents = "macro[macro.length-(count || 0)-1]" - -[[bind]] -path = "edit.action.history" -name = "replay stored" -description = """ -Replay a recorded Master Key command sequence from a named register, pushing -it to the front of the history stack. -""" -key = "q r" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.restoreNamed" -args.description = "Macro" -args.name = "macro" - -[[bind.args.commands]] -command = "master-key.pushHistoryToStack" -computedArgs.value = "captured" - -[[bind.args.commands]] -command = "master-key.replayFromStack" -args.index = 0 - -[[bind]] -path = "edit.action.history" -name = "store last" -description = """ -Store the N most recently run commands as a macro, where N is the count (defaulting to 1). -""" -key = "q l" -command = "master-key.pushHistoryToStack" -args.range.from = "i-(count || 0)" -args.range.to = "i" - -# ## Utility Commands - -# These actions include miscellaneous utilities. - -[[bind]] -path = "window" -key = "shift+ctrl+;" -name = "palette" -resetTransient = false -hideInPalette = true -mode = [] -prefixes = "" -description = """ -show command suggestions within the context of the current mode and keybinding prefix -(if any keys have already been typed) -""" -command = "master-key.commandPalette" - -[[bind]] -path = "util" -name = "git..." -description = "git commands" -key = "tab g" -command = "master-key.prefix" - -[[bind]] -path = "util" -name = "pull" -combinedName = "push/pull" -description = "pull changes from remote" -combinedDescription = "pull from/push to remote" -combinedKey = "p/shift+p" -key = "tab g p" -command = "git.pull" - -[[bind]] -path = "util" -name = "push" -description = "push changes to remote" -key = "tab g shift+p" -command = "git.push" - -[[bind]] -path = "util" -name = "checkout" -combinedName = "commit/checkout" -description = "commit changes" -combinedDescription = "commit/checkout git changes" -combinedKey = "c/shift+c" -key = "tab g c" -command = "git.commit" - -[[bind]] -path = "util" -name = "checkout" -combinedName = "commit/checkout" -description = "checkout changes" -key = "tab g shift+c" -command = "git.checkout" - -[[bind]] -path = "util" -name = "revert range" -description = "revert unstaged changes in selected range" -key = "tab g r" -command = "git.revertSelectedRanges" - -[[bind]] -path = "util" -name = "revert range" -description = "revert unstaged changes in selected range" -key = "tab g s" -command = "git.stageSelectedRanges" - -[[bind]] -path = "util" -name = "commands..." -description = "show GitLens command palette for git" -key = "tab g g" -command = "gitlens.gitCommands" - -# ## Miscellaneous Commands - -# These miscellaneous utility commands are all organized uner the prefix `tab`. - -[[path]] -id = "util" -name = "assorted misecellaneous commands" -default.kind = "util" -when = "editorTextFocus && !findWidgetVisible" - -[[bind]] -path = "util" -name = "utility" -key = "tab" -description = "utility related commands: file opening, window manipulation, debugging etc..." -command = "master-key.prefix" - -[[bind]] -path = "util" -name = "open recent" -description = "Open recent file" -key = "tab r" -command = "workbench.action.openRecent" - -[[bind]] -path = "util" -name = "hover" -description = "show the hover view" -combinedName = "(debug) hover" -combinedDescription = "show the (debug) hover view" -combinedKey = "(shift+)h" -key = "tab h" -command = "editor.action.showHover" - -[[bind]] -path = "util" -name = "debug hover" -combinedName = "(debug) hover" -description = "show the debug hover view" -key = "tab shift+h" -command = "editor.debug.action.showDebugHover" - -[[bind]] -path = "util" -name = "add mark" -combinedName = "add mark / mark..." -description = "toggle bookmark at given line" -combinedDescription = """ -toggle bookmark at given line / bookmark related commands -""" -key = "tab shift+m" -combinedKey = "shift+m / m" -command = "vsc-labeled-bookmarks.toggleBookmark" - -[[bind]] -path = "util" -name = "mark" -combinedName = "add mark / mark..." -description = "bookmark related commands" -key = "tab m" -command = "master-key.prefix" - -[[bind]] -path = "util" -name = "mark ↓" -description = "move to next bookmark" -combinedName = "mark ↓/↑" -combinedDescription = "move to next/previous bookmark" -combinedKey = "j/k" -key = "tab m j" -when = "!master-key.select_on && !editorHasSelection" -command = "vsc-labeled-bookmarks.navigateToNextBookmark" - -[[bind]] -path = "util" -combinedName = "mark ↓/↑" -key = "tab m j" -when = "master-key.select_on || editorHasSelection" -command = "vsc-labeled-bookmarks.expandSelectionToNextBookmark" - -[[bind]] -path = "util" -name = "mark ↑" -combinedName = "mark ↓/↑" -description = "move to previous bookmark" -key = "tab m k" -when = "!master-key.select_on && !editorHasSelection" -command = "vsc-labeled-bookmarks.navigateToPreviousBookmark" - -[[bind]] -path = "util" -name = "mark ↑" -combinedName = "mark ↓/↑" -description = "move to previous bookmark" -key = "tab m k" -when = "master-key.select_on || editorHasSelection" -command = "runCommands" -args.commands = [ - "vsc-labeled-bookmarks.expandSelectionToPreviousBookmark", - "selection-utilities.activeAtStart", -] - -[[bind]] -path = "util" -name = "remove mark" -description = "remove bookmark (use quick selection)" -key = "tab m d" -command = "vsc-labeled-bookmarks.deleteBookmark" - -[[bind]] -path = "util" -name = "nav marks" -description = "reveal quick selection to move to a bookmark" -key = "tab m t" -command = "vsc-labeled-bookmarks.navigateToBookmark" - -[[bind]] -path = "util" -name = "error →" -combinedName = "error →/←" -combinedDescription = "move to next/previous error" -combinedKey = "e/shift+e" -description = """ -move to next error -""" -key = "tab e" -command = "editor.action.marker.next" - -[[bind]] -path = "edit.motion" -name = "error ←" -combinedName = "error →/←" -description = """ -move to previous error -""" -key = "tab shift+e" -command = "editor.action.marker.prev" - -[[bind]] -path = "edit.motion" -name = "diff →" -combinedName = "diff →/←" -combinedDescription = "move to and show next/previous diff" -combinedKey = "c/shift+c" -description = """ -move to and show next diff -""" -key = "tab c" -command = "editor.action.dirtydiff.next" - -[[bind]] -path = "edit.motion" -name = "diff ←" -combinedName = "diff →/←" -description = """ -move to and show previous diff -""" -key = "tab shift+c" -command = "editor.action.dirtydiff.previous" - -[[bind]] -path = "edit.motion" -name = "change →" -combinedName = "change →/←" -combinedDescription = "move to next/previous file change" -combinedKey = "d/shift+d" -description = """ -move to next file change -""" -key = "tab d" -command = "workbench.action.editor.nextChange" - -[[bind]] -path = "edit.motion" -name = "change ←" -combinedName = "change →/←" -description = """ -move to previous change -""" -key = "tab shift+d" -command = "workbench.action.editor.previousChange" - -# ## Window Manipulation - -# These are commands that interact with VSCode's user-interface in some way, rather than editing or moving around in the editor pane. - -[[path]] -id = "window" -name = "Window Manipulation" -description = "Commands for navigating and manipulating the window/editor panes in some way" -default.kind = "util" -default.mode = "normal" -when = "editorTextFocus && !findWidgetVisible" - -[[bind]] -path = "window" -name = "cntr win" -description = "center window at primary cursor position" -key = "tab l" -command = "selection-utilities.revealActive" -args.at = "center" -when = "editorTextFocus" - -[[bind]] -path = "window" -name = "window" -description = "window/editor pane manipulation-related commands" -key = "tab w" -command = "master-key.prefix" - -[[bind]] -path = "window" -name = "vert/horz" -key = "tab w r" -description = "Toggle between horizontal and vertical layouts" -command = "workbench.action.toggleEditorGroupLayout" - -[[bind]] -path = "window" -name = "next window" -combinedName = "next/previous window" -description = "move to next window" -combinedDescription = "move to next/prev window" -key = "tab ]" -combinedKey = "]/[" -command = "workbench.action.focusNextGroup" - -[[bind]] -path = "window" -name = "prev window" -combinedName = "next/previous window" -description = "move to previous window" -key = "tab [" -command = "workbench.action.focusPreviousGroup" - -[[bind]] -path = "window" -name = "move →" -combinedName = "move →/←" -combinedDescription = "move editor to window left/right" -combinedKey = "l/h" -description = "move editor to window to left" -key = "tab w l" -command = "workbench.action.moveEditorToRightGroup" - -[[bind]] -path = "window" -name = "←" -combinedName = "move →/←" -description = "move editor to window to left" -key = "tab w h" -command = "workbench.action.moveEditorToLeftGroup" - -[[bind]] -path = "window" -name = "↓" -combinedName = "move ↓/↑" -combinedDescription = "move editor to window above/below" -combinedKey = "j/k" -description = "move editor to window below" -key = "tab w j" -command = "workbench.action.moveEditorToBelowGroup" - -[[bind]] -path = "window" -name = "↑" -combinedName = "move ↓/↑" -description = "move editor to window above" -key = "tab w k" -command = "workbench.action.moveEditorToAboveGroup" - -[[bind]] -path = "window" -name = "split editor..." -description = "split editor to in a given direction" -key = "tab w s" -command = "master-key.prefix" - -[[bind]] -path = "window" -name = "move →" -combinedName = "split →/←" -combinedDescription = "move editor to window left/right" -combinedKey = "l/h" -description = "split editor to window to left" -key = "tab w s l" -command = "workbench.action.splitEditorRight" - -[[bind]] -path = "window" -name = "←" -combinedName = "split →/←" -description = "split editor to window to left" -key = "tab w s h" -command = "workbench.action.splitEditorLeft" - -[[bind]] -path = "window" -name = "↓" -combinedName = "split ↓/↑" -combinedDescription = "split editor to window above/below" -combinedKey = "j/k" -description = "split editor to window below" -key = "tab w s j" -command = "workbench.action.splitEditorDown" - -[[bind]] -path = "window" -name = "↑" -combinedName = "split ↓/↑" -combinedDescription = "split editor to window above/below" -combinedKey = "j/k" -description = "split editor to window below" -key = "tab w s k" -command = "workbench.action.splitEditorUp" - -[[bind]] -path = "window" -name = "close pane" -description = "close the given group of editors" -key = "tab w x" -command = "workbench.action.closeEditorsInGroup" - -[[bind]] -path = "window" -name = "max" -description = "minimize size of all other windows" -key = "tab w shift+m" -command = "workbench.action.minimizeOtherEditors" - -[[bind]] -path = "window" -name = "equal" -description = "equalize size of all windows" -key = "tab w =" -command = "workbench.action.evenEditorWidths" - -[[bind]] -path = "window" -name = "curs. win top" -description = "center window so that primary cursor is at the top" -key = "tab k" -combinedName = "center window top/bottom" -combinedDescription = "center window so that primary cursor is at the top/bottom" -combinedKey = "k/j" -command = "selection-utilities.revealActive" -args.at = "top" - -[[bind]] -path = "window" -name = "curs. win bot" -combinedName = "center window top/bottom" -description = "center window so that primary cursor is at the bottom" -key = "tab j" -command = "selection-utilities.revealActive" -args.at = "bottom" - -# ## Debugging Commands - -# Commands for interacting with VSCode's debugger UI. - -[[bind]] -path = "util" -name = "breakpt." -combinedName = "breakpt / debug..." -combinedKey = "shift+b/b" -description = "toggle debug breakpoint" -combinedDescription = "toggle debug breakpoint / debug related commands..." -key = "tab shift+b" -command = "editor.debug.action.toggleBreakpoint" - -[[bind]] -path = "util" -name = "debug..." -combinedName = "breakpt / debug..." -description = "assorted debugging actions" -key = "tab b" -command = "master-key.prefix" - -[[bind]] -path = "util" -name = "cond. break" -description = "conditional breakpoint" -key = "tab b shift+c" -command = "editor.debug.action.conditionalBreakpoint" - - -[[bind]] -path = "util" -name = "start" -description = "start debugging" -key = "tab b r" -command = "workbench.action.debug.start" - -[[bind]] -path = "util" -name = "continue" -description = "continue debugging" -key = "tab b c" -command = "workbench.action.debug.continue" - -[[bind]] -path = "util" -name = "next" -description = "debug: step over next line" -key = "tab b j" -command = "workbench.action.debug.stepOver" - -[[bind]] -path = "util" -name = "into" -description = "debug: step into next line" -key = "tab b i" -command = "workbench.action.debug.stepInto" - -[[bind]] -path = "util" -name = "out" -description = "debug: step out" -key = "tab b o" -command = "workbench.action.debug.stepOut" - -# ## Select-edit Mode - -# Select-edit mode allows you make a variety of kakoune-like modifications of one or more cursors. This lends itself to work flows such as: -# -# - select every line of text as a separate cursor, then filter out the lines you don't want -# - split an array by comma delimiters and edit each element of the array. -# - save a single selection to a list of selections to use for later and -# then move the cursor to the next selection you wish to add - -[[path]] -id = "edit.select_edit" -name = "Selection Editing" -description = "Various kakaune inspired commands for editing multiple selections" -default.mode = "selectedit" -default.kind = "motion" - -[[bind]] -path = "edit.select_edit" -name = "select-edit" -description = """ -Enter a mode where you can edit and manipulate (possibly multiple) selections. -""" -key = "'" -command = "master-key.setMode" -args.value = "selectedit" -mode = "normal" - -[[bind]] -path = "edit.select_edit" -key = "shift+'" -combinedName = "rm cursors" -combinedKey = "shift/ctrl+'" -combinedDescription = "Delete all selections and return to normal (multiple key variants)" -name = "del. cursors" -description = "Delete all selections and return to normal" -command = "runCommands" -args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] -mode = ["selectedit", "normal"] - -[[bind]] -path = "edit.select_edit" -key = "ctrl+'" -mode = ["insert", "selectedit", "normal"] -name = "rm cursors" -combinedName = "rm cursors" -description = "Delete all selections and return to normal" -command = "runCommands" -args.commands = ["selection-utilities.cancelSelection", "master-key.enterNormal"] - -[[bind]] -path = "edit.select_edit" -name = 'normal' -description = "return to normal mode" -key = "'" -command = "master-key.enterNormal" - -[[bind]] -path = "edit.select_edit" -name = "add →" -combinedName = "add →/←" -description = "add cursor at the next match to the primary cursor's text" -combinedDescription = "add cursor at the next/previous match to the primary cursor's text" -key = "l" -combinedKey = "l/h" -repeat = "count" -command = "selection-utilities.addNext" - -[[bind]] -path = "edit.select_edit" -name = "add ←" -combinedName = "add →/←" -description = "add cursor at the previous match to the primary cursor's text" -key = "h" -command = "selection-utilities.addPrev" -repeat = 'count' - -[[bind]] -path = "edit.select_edit" -name = "skip →" -combinedName = "skip →/←" -description = "move primary cursor to the next match of the primary cursor's text" -combinedDescription = "move primary cursor to the next/previous match of the primary cursor's text" -key = "shift+l" -combinedKey = "shift+l/h" -command = "selection-utilities.skipNext" -repeat = "count" - -[[bind]] -path = "edit.select_edit" -name = "skip ←" -combinedName = "skip →/←" -description = "move primary cursor to the previous match of the primary cursor's text" -key = "shift+h" -command = "selection-utilities.skipPrev" -repeat = 'count' - -[[bind]] -path = "edit.select_edit" -name = "align ←" -description = "align selections left" -key = "=" -command = "selection-utilities.alignSelectionsLeft" - -[[bind]] -path = "edit.select_edit" -name = "align →" -description = "align selections right" -key = "shift+=" -command = "selection-utilities.alignSelectionsRight" - -[[bind]] -path = "edit.select_edit" -name = "→ sel" -combinedName = "→/← sel" -description = """ -make the next selection primary; primary selections determine from where you add cursors, -what cursor you delete, and where the cursor goes when you clear or save selections -""" -combinedDescription = """ -make the next/previous selection primary; primary selections determine from where you add cursors, -what cursor you delete, and where the cursor goes when you clear or save selections -""" -key = "j" -combinedKey = "j/l" -command = "selection-utilities.movePrimaryRight" -repeat = 'count' - -[[bind]] -path = "edit.select_edit" -name = "← sel" -combinedName = "→/← sel" -description = "make the previous selection primary; primary selections determine from where you add cursors, what cursor you delete, and where the cursor goes when you clear or save selections" -key = "k" -command = "selection-utilities.movePrimaryLeft" -repeat = 'count' - -[[bind]] -path = "edit.select_edit" -name = "insert ↑" -combinedName = "insert ↑/↓" -description = """ -insert cursor on line above -""" -combinedDescription = "insert cursor on line above/below" -key = "shift+k" -combinedKey = "shift+k/j" -command = "editor.action.insertCursorAbove" -repeat = "count" - -[[bind]] -path = "edit.select_edit" -name = "insert sel ↓" -combinedName = "insert ↑/↓" -description = """ -insert cursor on line below -""" -key = "shift+j" -command = "editor.action.insertCursorBelow" -repeat = "count-1" - -[[bind]] -path = "edit.select_edit" -name = "del. primary" -combinedName = "del. primary/others" -description = "remove the primary selection" -combinedDescription = """ -Remove either the primary selection or all selections. Return to normal -mode if all selections are deleted. -""" -key = "d" -command = "selection-utilities.deletePrimary" -repeat = "count-1" - -[[bind]] -path = "edit.select_edit" -name = 'del. others' -description = "delete all other cursors but the primary selection" -key = "shift+d" -command = "removeSecondaryCursors" - -[[bind]] -path = "edit.select_edit" -name = "save sel" -description = """ -save all selections to the default register. -Use a count to specify an alternate register -""" -key = "c" -command = "runCommands" -args.commands = [ - { command = "selection-utilities.appendToMemory", computedArgs = { register = "count || 'default'" } }, - "selection-utilities.shrinkToActive", - "master-key.enterNormal", -] - -[[bind]] -path = "edit.select_edit" -name = "load sel" -description = """ -load previously saved selections in the default register. -Use a count to specify an alternate register -""" -key = "v" -command = "runCommands" -args.commands = [ - { command = "selection-utilities.restoreAndClear", computedArgs = { register = "count || 'default'" } }, -] - -[[bind]] -path = "edit.select_edit" -name = "exchange sel" -description = """ -exchange selections: with no saved selection, saves the selection, with saved selections exchanges text of current selections with those of the saved selections (number of selections must match). Use a count to specify an alternate register. -""" -key = "x" -command = "runCommands" -args.commands = [ - { command = "selection-utilities.swapWithMemory", computedArgs = { register = "count || 'default'" } }, - "master-key.enterNormal", -] - -[[bind]] -path = "edit.select_edit" -name = "rem saved sel" -description = """ -remove the most recently saved selection from the list of saved selections -""" -command = "runCommands" -key = "n" -args.commands = [ - { command = "selection-utilities.deleteLastSaved", computedArgs = { register = "count || 'default'" } }, - "master-key.enterNormal", -] - -[[bind]] -path = "edit.select_edit" -key = "shift+enter" -name = "split sel" -description = """ -split selection into multiple selections by new line charactesr -""" -command = "selection-utilities.splitByNewline" - -[[bind]] -path = "edit.select_edit" -name = "sel all" -description = """ -create a selection for every match of the current word (or selection) -""" -key = "shift+8" -command = "editor.action.selectHighlights" - -[[bind]] -path = "edit.select_edit" -name = "character" -description = "split by a given character" -key = "s" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.captureKeys" -args.acceptAfter = 1 - -[[bind.args.commands]] -command = "selection-utilities.splitBy" -computedArgs.text = "captured" - -[[bind]] -path = "edit.select_edit" -name = "string" -description = "split by a given string" -key = "shift+s" -command = "selection-utilities.splitBy" - -[[bind]] -path = "edit.select_edit" -name = "include" -description = """ -Include all selections that contain a given marker -""" -key = "f" -command = "selection-utilities.includeBy" - -[[bind]] -path = "edit.select_edit" -name = "exclude" -description = """ -Exclude all selections that contain a given marker -""" -key = "shift+f" -command = "selection-utilities.excludeBy" - -[[bind]] -path = "edit.select_edit" -name = "create" -description = "create selections of given string scoped to the current selections" -key = "/" -command = "selection-utilities.createBy" - -[[bind]] -path = "edit.select_edit" -name = "regex" -description = "operations by regex rather than string" -key = "r" -command = "master-key.prefix" - -[[bind]] -path = "edit.select_edit" -name = "split" -description = "split by a given regular expression" -key = "r shift+s" -command = "selection-utilities.splitByRegex" - -[[bind]] -path = "edit.select_edit" -name = "create" -description = "create selections of given regular expression scoped to the current selections" -key = "r /" -command = "selection-utilities.createByRegex" - -[[bind]] -path = "edit.select_edit" -name = "include" -description = "Include all selections that contain a given regular expression" -key = "r f" -command = "selection-utilities.includeByRegex" - -[[bind]] -path = "edit.select_edit" -name = "exclude" -description = "Exclude all selections that contain a given regular expression" -key = "r shift+f" -command = "selection-utilities.excludeByRegex" - -[[bind]] -path = "edit.select_edit" -key = "o" -name = "active to front" -combinedKey = "o/shift+o" -combinedName = "active to start/end" -combinedDescription = "move cursor to start/end of selection" -description = "move cursor to start of selection" -command = "selection-utilities.activeAtEnd" - -[[bind]] -path = "edit.select_edit" -name = "active to end" -combinedName = "active to start/end" -description = "move cursor to back of selection" -key = "shift+o" -command = "selection-utilities.activeAtStart" - -# ## Symmetric Insert Mode - -# Symmetric insert mode allows you to edit text at both the start and the beginning of a selection. When entering a character with a complimentary pair (e.g. `(` to `)`) entry is handled in the expected way. For example if you type `(` at the start of a selection while in symmetric insert mode, `)` will apepar at the end of the selection. - -# As a general rule, the letter keys issue commands of various sorts, and the other keys can be used to enter text (since we rarley want to surround a selection with an `a` but might want to surround it with `*` or `/`. - -[define.braces] - -"{".before = "{" -"{".after = "}" -"}".before = "{" -"}".after = "}" - -"[".before = "[" -"[".after = "]" -"]".before = "[" -"]".after = "]" - -"(".before = "(" -"(".after = ")" -")".before = "(" -")".after = ")" - -"<".before = "<" -"<".after = ">" -">".before = "<" -">".after = ">" - -[[mode]] -name = "syminsert" -highlight = "Highlight" -cursorShape = "BlockOutline" - -[[mode.onType]] -command = "selection-utilities.insertAround" -computedArgs.before = "braces[captured].before || captured" -computedArgs.after = "braces[captured].after || captured" -args.followCursor = true - -[[path]] -id = "edit.action.symmetric" -name = "Symmetric Operations" -description = "Operations that occur at both ends of a selection" -default.kind = "action" -default.mode = "syminsert" - -[[path]] -id = "edit.motion.symmetric" -name = "Symmetric Motions" -description = "Motions that occur at both ends of a selection" -default.kind = "motion" -default.mode = "syminsert" - -[[bind]] -path = "edit.action.symmetric" -name = "sym insert mode" -priority = 1 -description = """ -In this mode all commands and character insertions happen at both ends of -the selection -""" -mode = "normal" -key = "space shift+i" -combinedName = "sym insert (mode)" -command = "master-key.setMode" -args.value = "syminsert" - -[[bind]] -path = "edit.action.symmetric" -name = "Normal" -description = "Return to normal model" -key = "enter" -command = "master-key.setMode" -mode = "syminsert" - -[[bind]] -path = "edit.action.symmetric" -foreach.key = ["{key: [a-z]}", "shift+{key: [a-z]}"] -name = "" -description = "this key is ignored and has no associated command in syminsert mode" -key = "{key}" -command = "master-key.ignore" -mode = "syminsert" -hideInDocs = true -hideInPalette = true - -[[bind]] -name = "esc. char" -path = "edit.action.symmetric" -key = "\\" -description = "Insert escaped character" -command = "runCommands" - -[[bind.args.commands]] -command = "master-key.captureKeys" -args.acceptAfter = 1 - -[[bind.args.commands]] -command = "selection-utilities.insertAround" -computedArgs.before = "'\\\\' + (braces[captured].before || captured)" -computedArgs.after = "'\\\\' + (braces[captured].after || captured)" -args.followCursor = true - -[[bind]] -path = "edit.action.symmetric" -name = "delete" -key = "x" -description = """ -delete the first and last adjacent character when cursor is at end of selection and -delete the first and last character *in* the selection when cursor is at the start of the -selection -""" -command = "selection-utilities.deleteAround" -computedArgs.count = "count" -args.followCursor = true - -[[bind]] -path = "edit.motion.symmetric" -key = "l" -name = "sel →" -description = "shrink/grow selections in direction that's rightwards from cursor" -command = "selection-utilities.adjustSelections" -args.dir = "forward" -computedArgs.count = "count" - -[[bind]] -path = "edit.motion.symmetric" -key = "h" -name = "sel ←" -description = "shrink/grow selections in direction that's leftwards from cursor" -command = "selection-utilities.adjustSelections" -args.dir = "backward" -computedArgs.count = "count" - -[[bind]] -path = "edit.motion.symmetric" -key = "o" -name = "active to front" -combinedKey = "o/shift+o" -combinedName = "active to start/end" -combinedDescription = "move cursor to start/end of selection" -description = "move cursor to start of selection" -command = "selection-utilities.activeAtEnd" - -[[bind]] -path = "edit.motion.symmetric" -name = "active to end" -combinedName = "active to start/end" -description = "move cursor to back of selection" -key = "shift+o" -command = "selection-utilities.activeAtStart" - -[[bind]] -path = "edit.action.symmetric" -name = "undo" -key = "u" -command = "undo" - -[[bind]] -path = "edit.action.symmetric" -name = "redo" -key = "shift+u" -command = "redo" - -[[bind]] -path = "edit.motion.symmetric" -key = "v" -name = "shrink selection" -description = """ -reduce all selections to length zero and return to normal mode -""" -command = "runCommands" -args.commands = [ - "selection-utilities.shrinkToActive", - { command = "master-key.setFlag", args = { name = "select_on", value = false } }, - "master-key.enterNormal", -] diff --git a/old_format/parsing.ts b/old_format/parsing.ts deleted file mode 100644 index 3f08ed5c..00000000 --- a/old_format/parsing.ts +++ /dev/null @@ -1,459 +0,0 @@ -import * as vscode from 'vscode'; -const TOML = require('smol-toml'); -import * as semver from 'semver'; -import z, {ZodIssue} from 'zod'; -import {ZodError, fromZodError, fromZodIssue} from 'zod-validation-error'; -import {expressionId} from '../expressions'; -import {uniqBy} from 'lodash'; -import replaceAll from 'string.prototype.replaceall'; -import {IParsedBindingDoc, parseBindingDocs} from './docParsing'; -export const INPUT_CAPTURE_COMMANDS = [ - 'captureKeys', - 'replaceChar', - 'insertChar', - 'search', -]; - -const bindingHeader = z - .object({ - version: z - .string() - .refine(x => semver.coerce(x), { - message: 'header.version is not a valid version number', - }) - .refine(x => semver.satisfies(semver.coerce(x)!, '1'), { - message: - 'header.version is not a supported version number (must a compatible with 1.0)', - }), - requiredExtensions: z.string().array().optional(), - name: z.string().optional(), - description: z.string().optional(), - }) - .strict(); -// type BindingHeader = z.infer; - -const rawBindingCommand = z - .object({ - command: z.string().optional(), // only optional before default expansion - args: z.any(), - computedArgs: z.object({}).passthrough().optional(), - if: z.string().or(z.boolean()).default(true).optional(), - }) - .strict(); -export type RawBindingCommand = z.infer; - -const definedCommand = z.object({defined: z.string()}).strict(); -export type DefinedCommand = z.infer; - -const ALLOWED_MODIFIERS = /Ctrl|Shift|Alt|Cmd|Win|Meta/i; -const ALLOWED_KEYS = [ - /f[1-9]/i, - /f1[0-9]/i, - /[a-z]/, - /[0-9]/, - /`/, - /-/, - /=/, - /\[/, - /\]/, - /\\/, - /;/, - /'/, - /,/, - /\./, - /\//, - /left/i, - /up/i, - /right/i, - /down/i, - /pageup/i, - /pagedown/i, - /end/i, - /home/i, - /tab/i, - /enter/i, - /escape/i, - /space/i, - /backspace/i, - /delete/i, - /pausebreak/i, - /capslock/i, - /insert/i, - /numpad[0-9]/i, - /numpad_multiply/i, - /numpad_add/i, - /numpad_separator/i, - /numpad_subtract/i, - /numpad_decimal/i, - /numpad_divide/i, - // layout independent versions - /\[f[1-9]\]/i, - /\[f1[0-9]\]/i, - /\[Key[A-Z]\]/i, - /\[Digit[0-9]\]/i, - /\[Numpad[0-9]\]/i, - /\[Backquote\]/, - /\[Minus\]/, - /\[Equal\]/, - /\[BracketLeft\]/, - /\[BracketRight\]/, - /\[Backslash\]/, - /\[Semicolon\]/, - /\[Quote\]/, - /\[Comma\]/, - /\[Period\]/, - /\[Slash\]/, - /\[ArrowLeft\]/, - /\[ArrowUp\]/, - /\[ArrowRight\]/, - /\[ArrowDown\]/, - /\[PageUp\]/, - /\[PageDown\]/, - /\[End\]/, - /\[Home\]/, - /\[Tab\]/, - /\[Enter\]/, - /\[Escape\]/, - /\[Space\]/, - /\[Backspace\]/, - /\[Delete\]/, - /\[Pause\]/, - /\[CapsLock\]/, - /\[Insert\]/, - /\[NumpadMultiply\]/, - /\[NumpadAdd\]/, - /\[NumpadComma\]/, - /\[NumpadSubtract\]/, - /\[NumpadDecimal\]/, - /\[NumpadDivide\]/, -]; - -function fullMatch(x: string, ex: RegExp) { - const m = x.match(ex); - if (m === null) { - return false; - } - return m[0].length === x.length; -} - -function isAllowedKeybinding(key: string) { - for (const press of key.split(/\s+/)) { - const modsAndPress = press.split('+'); - for (const mod of modsAndPress.slice(0, -1)) { - if (!ALLOWED_MODIFIERS.test(mod)) { - return false; - } - } - const unmodPress = modsAndPress[modsAndPress.length - 1]; - if (ALLOWED_KEYS.every(a => !fullMatch(unmodPress, a))) { - return false; - } - } - return true; -} - -export async function showParseError(prefix: string, error: ZodError | ZodIssue) { - let suffix = ''; - if ((error).code === undefined) { - // code is always defined on issues and undefined on errors - suffix = fromZodError(error).message; - } else { - suffix = fromZodIssue(error).message; - } - const buttonPattern = /\s+\{button:\s*"(.+)(? x.toLowerCase()); - -// function prefixError(arg: string) { -// return { -// message: `Expected either an array of kebydinings or the string '', -// but got '${arg}' instead`, -// }; -// } - -const parsedWhen = z.object({ - str: z.string(), - id: z.string(), -}); -export type ParsedWhen = z.infer; - -export function parseWhen(when_: string | string[] | undefined): ParsedWhen[] { - const when = when_ === undefined ? [] : !Array.isArray(when_) ? [when_] : when_; - return when.map(w => { - w = replaceAll( - w, - /editorTextFocus/g, - '(editorTextFocus || master-key.keybindingPaletteOpen && master-key.keybindingPaletteBindingMode)' - ); - // let p = jsep(w); - return {str: w, id: expressionId(w)}; - }); -} - -export const vscodeBinding = z.object({ - key: bindingKey, - command: z.string(), - args: z.object({}).optional(), - when: z.string().optional(), -}); - -export const rawBindingItem = z - .object({ - name: z.string().optional(), - description: z.string().optional(), - hideInPalette: z.boolean().default(false).optional(), - hideInDocs: z.boolean().default(false).optional(), - combinedName: z.string().optional().default(''), - combinedKey: z.string().optional().default(''), - combinedDescription: z.string().optional().default(''), - path: z.string().optional(), - priority: z.number().default(0).optional(), - kind: z.string().optional(), - key: z.string().optional(), - foreach: z.record(z.string(), z.array(z.string())).optional(), - when: z - .union([z.string(), z.string().array()]) - .optional() - .transform(parseWhen) - .pipe(parsedWhen.array()), - mode: z.union([z.string(), z.string().array()]).optional(), - prefixes: z - .preprocess( - x => (x === '' ? [] : x), - bindingKey.or(z.string().length(0)).array() - ) - .optional(), - resetTransient: z.boolean().optional(), - repeat: z.number().min(0).or(z.string()).default(0).optional(), - }) - .merge(rawBindingCommand) - .strict(); -export type RawBindingItem = z.output; - -// a strictBindingItem is satisfied after expanding all default fields -export const bindingCommand = rawBindingCommand.required({command: true}); -export type BindingCommand = z.infer; - -export const doArgs = bindingCommand.array().refine( - xs => { - let acceptsInput = 0; - for (const x of xs) { - if (INPUT_CAPTURE_COMMANDS.some(i => i === x.command)) { - acceptsInput = +1; - } - } - return acceptsInput <= 1; - }, - { - message: - '`runCommand` arguments can include only one command that accepts user input.', - } -); -export type DoArgs = z.infer; - -// TODO: the errors are not very informative if we transform the result so early in this -// way; we need to keep this as close as possible to the form in the raw file -export const bindingItem = z - .object({ - key: bindingKey, - when: parsedWhen.array(), - command: z.literal('master-key.do'), - mode: z - .string() - .or(z.object({implicit: z.string()})) - .array() - .optional(), - prefixes: z.string().array().optional().default(['']), - args: z - .object({ - do: doArgs, - path: z.string().optional().default(''), - hideInPalette: z.boolean().default(false).optional(), - hideInDocs: z.boolean().default(false).optional(), - priority: z.number().optional().default(0), - combinedName: z.string().optional().default(''), - combinedKey: z.string().optional().default(''), - combinedDescription: z.string().optional().default(''), - resetTransient: rawBindingItem.shape.resetTransient, - kind: z.string().optional().default(''), - repeat: z.number().min(0).or(z.string()).default(0), - }) - .merge(rawBindingItem.pick({name: true, description: true})), - }) - .required({key: true, when: true, args: true}) - .strict(); -export type BindingItem = z.output; - -export const bindingPath = z.object({ - // TODO: change from an empty `id` path, to fields at the top level in the header - id: z.string().regex(/(^$|[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)*)/), - name: z.string(), - description: z.string().optional(), - default: rawBindingItem.partial().optional(), - when: z.string().optional().transform(parseWhen).pipe(parsedWhen.array().optional()), -}); - -const modeSpec = z.object({ - name: z.string(), - default: z.boolean().optional().default(false), - highlight: z.enum(['NoHighlight', 'Highlight', 'Alert']).default('NoHighlight'), - recordEdits: z.boolean().optional().default(false), - cursorShape: z - .enum(['Line', 'Block', 'Underline', 'LineThin', 'BlockOutline', 'UnderlineThin']) - .default('Line'), - onType: doArgs.optional(), - fallbackBindings: z.string().optional().default(''), -}); -export type ModeSpec = z.output; - -const kindItem = z - .object({ - name: z.string(), - description: z.string(), - }) - .strict(); -export type KindItem = z.output; - -export const bindingSpec = z - .object({ - header: bindingHeader, - bind: rawBindingItem.array(), - kind: kindItem.array().optional(), - path: bindingPath - .array() - .refine(xs => uniqBy(xs, x => x.id).length === xs.length, { - message: "Defined [[path]] entries must all have unique 'id' fields.", - }) - .optional() - .default([]), - mode: modeSpec - .array() - .optional() - .default([ - { - name: 'default', - default: true, - recordEdits: true, - cursorShape: 'Line', - highlight: 'NoHighlight', - }, - ]) - .refine( - xs => { - return uniqBy(xs, x => x.name).length === xs.length; - }, - {message: 'All mode names must be unique!'} - ) - .refine( - xs => { - const defaults = xs.filter(x => x.default); - return defaults.length === 1; - }, - {message: 'There must be one and only one default mode'} - ) - .transform(xs => { - const captureMode = xs.filter(x => x.name === 'capture'); - if (captureMode.length === 0) { - return xs.concat({ - name: 'capture', - cursorShape: 'Underline', - default: false, - recordEdits: false, - highlight: 'Highlight', - fallbackBindings: '', - }); - } - return xs; - }), - define: z.record(z.string(), z.any()).optional().default({}), - }) - .strict(); -export type BindingSpec = z.infer; - -export type FullBindingSpec = BindingSpec & { - doc?: IParsedBindingDoc[]; -}; - -export interface SuccessResult { - success: true; - data: T; -} -export interface ErrorResult { - success: false; - error: ZodError; -} -export type ParsedResult = SuccessResult | ErrorResult; - -export async function parseBindings(text: string): Promise> { - const data = bindingSpec.safeParse((await TOML).parse(text)); - if (data.success) { - const doc = parseBindingDocs(text); - - if (doc.success) { - return {success: true, data: {...data.data, doc: doc.data?.doc}}; - } else { - return >doc; - } - } else { - return >data; - } -} - -export async function parseBindingFile(file: vscode.Uri) { - const fileData = await vscode.workspace.fs.readFile(file); - const fileText = new TextDecoder().decode(fileData); - return parseBindings(fileText); -} - -export interface IConfigKeyBinding { - key: string; - command: 'master-key.do'; - prefixDescriptions: string[]; - when: string; - args: { - do: DoArgs; - key: string; // repeated here so that commands can display the key pressed - name?: string; - description?: string; - resetTransient?: boolean; - hideInPalette?: boolean; - hideInDocs?: boolean; - priority: number; - combinedName: string; - combinedKey: string; - combinedDescription: string; - kind: string; - path: string; - mode: string | undefined; - prefixCode: number | undefined; - }; -} diff --git a/src/extension/keybindings/index.ts b/src/extension/keybindings/index.ts index 0f045952..be437ff7 100644 --- a/src/extension/keybindings/index.ts +++ b/src/extension/keybindings/index.ts @@ -695,7 +695,7 @@ export async function activate(context: vscode.ExtensionContext) { const encoder = new TextEncoder(); vscode.workspace.onDidChangeTextDocument(async (e) => { - if (e.document.languageId == 'toml') { + if (e.document.languageId == 'toml' || e.document.uri.fsPath.endsWith('.toml')) { debounce(() => { const text = e.document.getText(); const bytes = encoder.encode(text); @@ -705,12 +705,12 @@ export async function activate(context: vscode.ExtensionContext) { }); vscode.workspace.onDidSaveTextDocument(async (e) => { - if (e.languageId == 'toml') { + if (e.languageId == 'toml' || e.uri.fsPath.endsWith('.toml')) { await validateKeybindings(e.uri); } }); vscode.workspace.onDidOpenTextDocument(async (e) => { - if (e.languageId == 'toml') { + if (e.languageId == 'toml' || e.uri.fsPath.endsWith('.toml')) { await validateKeybindings(e.uri); } }); diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index f217e306..ded3783f 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -342,6 +342,7 @@ pub struct KeyFileResult { pub fn parse_keybinding_bytes(file_content: Box<[u8]>) -> KeyFileResult { let mut warnings = Vec::new(); let result = parse_bytes_helper(&file_content, &mut warnings); + warnings.append(&mut identify_legacy_warnings(&file_content)); return match result { Ok(result) => KeyFileResult { file: Some(result), @@ -448,28 +449,11 @@ impl LegacyKeyFileInput { } } -pub fn identify_legacy_warnings_helper(file_content: &[u8]) -> ResultVec<()> { - let warnings = toml::from_slice::(&file_content)?; - return Err(warnings.check()); -} - -pub fn identify_legacy_warnings(file_content: Box<[u8]>) -> KeyFileResult { - return match identify_legacy_warnings_helper(&file_content) { - Ok(()) => KeyFileResult { - file: None, - errors: None, - }, - Err(e) => KeyFileResult { - file: None, - errors: Some( - e.errors - .iter() - .map(|x| x.report(&file_content)) - .filter(Option::is_some) - .map(Option::unwrap) - .collect(), - ), - }, +pub fn identify_legacy_warnings(file_content: &[u8]) -> Vec { + let warnings = toml::from_slice::(&file_content); + return match warnings { + Ok(x) => x.check().errors, + Err(_) => Vec::new(), }; } @@ -1543,10 +1527,9 @@ pub(crate) mod tests { when = "!findWidgetVisible" "#; - let warnings = identify_legacy_warnings_helper(data.as_bytes()).unwrap_err(); + let warnings = identify_legacy_warnings(data.as_bytes()); assert_eq!( warnings - .errors .iter() .filter(|x| x.error.to_string().contains("2.0")) .collect::>() diff --git a/src/test/integration/test-workspace/my_bindings.mk.toml b/src/test/integration/test-workspace/my_bindings.mk.toml index ee902062..f641cbb8 100644 --- a/src/test/integration/test-workspace/my_bindings.mk.toml +++ b/src/test/integration/test-workspace/my_bindings.mk.toml @@ -1,28 +1,13 @@ + #:master-keybindings -[[define.bind]] -id = "my_defaults" -command = "bar" + [header] + version = "2.0.0" -[[bind]] -default = "{{bind.my_defaults}}" -args = { a = "2", b = 3, c = "{{x + 1}}" } -when = "joe > 1" -mode = "normal" -priority = 1 -prefixes = "c" -finalKey = true -repeat = "{{2+c}}" -name = "foo" -description = "foo bar bin" -hideInPalette = false -hideInDocs = false -combinedName = "foo/bar" -combinedKey = "A/B" -combinedDescription = "bla bla bla" -kind = "biz" + [[bind]] + doc.name = "default" + command = "foobar" -[[bind]] -foreach.key = ["{{keys(`[0-9]`)}}"] -key = "c {{key}}" -command = "foobar" -args.value = "{{key}}" + [[bind]] + doc.name = "run_merged" + key = "k" + command = "bizbaz" diff --git a/src/test/unit/change-mk-toml.test.ts b/src/test/unit/change-mk-toml.test.ts index 03374f99..5392bb4b 100644 --- a/src/test/unit/change-mk-toml.test.ts +++ b/src/test/unit/change-mk-toml.test.ts @@ -2,60 +2,96 @@ import * as vscode from 'vscode'; import * as assert from 'assert'; import { editorWithText } from './utils'; -suite('*.mk.toml Linting', () => { +suite('*.toml Linting', () => { test('Good file has no linting', async function () { this.timeout(5000); const body = ` + #:master-keybindings + + [header] + version = "2.0.0" + [[bind]] - name = "default" + doc.name = "default" command = "foobar" key = "a" [[bind]] - name = "run_merged" + doc.name = "run_merged" key = "k" command = "bizbaz" `; - const [_editor, fileUri] = await editorWithText(body, '.mk.toml'); + const [_editor, fileUri] = await editorWithText(body, '.toml'); + await vscode.window.activeTextEditor?.document.save(); - const diags = vscode.languages.getDiagnostics(); - for (const [file, diag] of diags) { - if (file.path.endsWith('mk.toml')) { - assert.equal(diag.length, 0); - } - } - - await vscode.workspace.fs.delete(fileUri); + // TODO: check diagnostics on a specific file, and ideally use this event + // so we don't have to guess about when it's done (and move this before the call to + // save?) + const diags = vscode.languages.getDiagnostics(fileUri); + assert.equal(diags.length, 0); }); test('Bad file causes a lint error', async function () { this.timeout(5000); // NOTE: there is no `key` field const body = ` + #:master-keybindings + + [header] + version = "2.0.0" + [[bind]] - name = "default" + doc.name = "default" command = "foobar" [[bind]] - name = "run_merged" + doc.name = "run_merged" key = "k" command = "bizbaz" `; - const [_editor, fileUri] = await editorWithText(body, '.mk.toml'); + const [_editor, fileUri] = await editorWithText(body, '.toml'); + // trigger file validation + await vscode.window.activeTextEditor?.document.save(); + + const diag = vscode.languages.getDiagnostics(fileUri); + + assert.notEqual(diag.length, 0); + const error = diag.find(d => /`key` field/.test(d.message)); + assert.equal(error?.severity, vscode.DiagnosticSeverity.Error); + assert.notEqual(error, undefined); + }); + + test('Sketchy file causes a lint warning', async function () { + this.timeout(5000); + // NOTE: `name` is not prefixed with `doc` + const body = ` + #:master-keybindings + + [header] + version = "2.0.0" + + [[bind]] + name = "default" + key = "a" + command = "foobar" + + [[bind]] + doc.name = "run_merged" + key = "k" + command = "bizbaz" + `; - const diags = vscode.languages.getDiagnostics(); + const [_editor, fileUri] = await editorWithText(body, '.toml'); + // trigger file validation + await vscode.window.activeTextEditor?.document.save(); - assert.notEqual(diags.length, 0); - for (const [file, diag] of diags) { - if (file.path.endsWith('mk.toml')) { - assert.notEqual(diag.length, 0); - const error = diag.find(d => d.message == 'requires `key` field\n'); - assert.notEqual(error, undefined); - } - } + const diag = vscode.languages.getDiagnostics(fileUri); - await vscode.workspace.fs.delete(fileUri); + assert.notEqual(diag.length, 0); + const error = diag.find(d => /`name` no longer exists/.test(d.message)); + assert.equal(error?.severity, vscode.DiagnosticSeverity.Warning); + assert.notEqual(error, undefined); }); }); From 94d298ebb7378a836fab8ea36b27238606f4c14c Mon Sep 17 00:00:00 2001 From: David Little Date: Sun, 19 Oct 2025 00:25:13 -0400 Subject: [PATCH 79/79] cleanup mode.whenNoBinding parsing Created using spr 1.3.6-beta.1 --- notes.md | 4 +- src/rust/parsing/src/bind.rs | 3 +- src/rust/parsing/src/bind/command.rs | 10 +- src/rust/parsing/src/bind/foreach.rs | 2 +- src/rust/parsing/src/bind/prefix.rs | 1 - src/rust/parsing/src/error.rs | 42 ++--- src/rust/parsing/src/file.rs | 222 ++++++++++++++++++++++++--- src/rust/parsing/src/mode.rs | 105 ++++++++++++- src/rust/parsing/src/util.rs | 18 +-- 9 files changed, 325 insertions(+), 82 deletions(-) diff --git a/notes.md b/notes.md index e442895d..0e0c6503 100644 --- a/notes.md +++ b/notes.md @@ -254,7 +254,7 @@ Integration test debugging: the last key as a valid prefix) - [X] unit tests - [X] documentation - - [ ] error handling checks + - [X] error handling checks - [X] remove spurious line/char positions from expression error messages - NOTE: these come from the line and char position in the rhai expression which has nothing to do with the line and char position in the parent @@ -311,7 +311,7 @@ Integration test debugging: - [X] get it working in debug - [X] update tests - [X] debug unreliable test outcomes - - [ ] validate modes to ensure that at least one of them allows the user to type 😬 + - [X] validate modes to ensure that at least one of them allows the user to type 😬 - [ ] refactor and cleanup rust code - [ ] proper conversion to keybindings.json command - [X] expand per mode and prefix (e.g. each binding has one mode and one prefix) diff --git a/src/rust/parsing/src/bind.rs b/src/rust/parsing/src/bind.rs index 063f82da..d5783ff4 100644 --- a/src/rust/parsing/src/bind.rs +++ b/src/rust/parsing/src/bind.rs @@ -5,7 +5,6 @@ use core::ops::Range; use indexmap::IndexMap; use lazy_static::lazy_static; use regex::Regex; -use rhai::{EvalAltResult, ImmutableString}; use serde::{Deserialize, Serialize}; use std::collections::hash_map::{Entry, OccupiedEntry}; use std::collections::{HashMap, HashSet}; @@ -22,7 +21,7 @@ pub mod validation; use crate::bind::command::{Command, regularize_commands}; use crate::bind::prefix::{Prefix, PrefixInput}; use crate::bind::validation::{BindingReference, KeyBinding}; -use crate::error::{ErrorContext, ParseError, Result, ResultVec, err, wrn}; +use crate::error::{ErrorContext, ParseError, Result, ResultVec, err}; use crate::expression::Scope; use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::resolve; diff --git a/src/rust/parsing/src/bind/command.rs b/src/rust/parsing/src/bind/command.rs index ea6b8d0f..6e0d6dfa 100644 --- a/src/rust/parsing/src/bind/command.rs +++ b/src/rust/parsing/src/bind/command.rs @@ -10,7 +10,7 @@ use wasm_bindgen::{JsValue, prelude::wasm_bindgen}; use crate::{ bind::{BindingInput, UNKNOWN_RANGE}, err, - error::{ErrorContext, Result, ResultVec, err}, + error::{ErrorContext, Result, ResultVec, err, flatten_errors}, expression::{ Scope, value::{Expanding, Expression, TypedValue, Value}, @@ -393,6 +393,14 @@ impl Expanding for Command { } } +impl Resolving> for Vec { + fn resolve(self, name: &'static str, scope: &mut Scope) -> ResultVec> { + Ok(flatten_errors( + self.into_iter().map(|x| x.resolve(name, scope)), + )?) + } +} + #[cfg(test)] mod tests { use crate::bind::command::regularize_commands; diff --git a/src/rust/parsing/src/bind/foreach.rs b/src/rust/parsing/src/bind/foreach.rs index 747f5a12..7695ba6f 100644 --- a/src/rust/parsing/src/bind/foreach.rs +++ b/src/rust/parsing/src/bind/foreach.rs @@ -42,7 +42,7 @@ use regex::Regex; use rhai::{EvalAltResult, ImmutableString}; use toml::Spanned; -use crate::error::{ErrorContext, ResultVec, flatten_errors}; +use crate::error::{ResultVec, flatten_errors}; use crate::expression::Scope; use crate::expression::value::{Expanding, Value}; diff --git a/src/rust/parsing/src/bind/prefix.rs b/src/rust/parsing/src/bind/prefix.rs index e2bac2d7..72402181 100644 --- a/src/rust/parsing/src/bind/prefix.rs +++ b/src/rust/parsing/src/bind/prefix.rs @@ -4,7 +4,6 @@ use crate::expression::value::{Expanding, Expression, TypedValue, Value}; use crate::util::{LeafValue, Merging, Plural, Resolving}; use serde::{Deserialize, Serialize}; -use wasm_bindgen::prelude::*; // TODO: we could improve error messages here by implementing Deserialize ourselves #[derive(Deserialize, Clone, Debug)] diff --git a/src/rust/parsing/src/error.rs b/src/rust/parsing/src/error.rs index eb384739..85b7f905 100644 --- a/src/rust/parsing/src/error.rs +++ b/src/rust/parsing/src/error.rs @@ -74,21 +74,21 @@ pub fn err(msg: &'static str) -> RawError { return RawError::Static(msg); } -pub fn wrn(msg: &'static str) -> ParseError { - return ParseError { - error: RawError::Static(msg), - contexts: SmallVec::new(), - level: ErrorLevel::Warn, - }; -} - -pub fn note(msg: &'static str) -> ParseError { - return ParseError { - error: RawError::Static(msg), - contexts: SmallVec::new(), - level: ErrorLevel::Info, - }; -} +// pub fn wrn(msg: &'static str) -> ParseError { +// return ParseError { +// error: RawError::Static(msg), +// contexts: SmallVec::new(), +// level: ErrorLevel::Warn, +// }; +// } + +// pub fn note(msg: &'static str) -> ParseError { +// return ParseError { +// error: RawError::Static(msg), +// contexts: SmallVec::new(), +// level: ErrorLevel::Info, +// }; +// } #[wasm_bindgen] #[derive(Debug, Error, Clone)] @@ -520,15 +520,3 @@ pub struct ErrorReport { pub range: CharRange, pub level: ErrorLevel, } - -#[wasm_bindgen] -impl ErrorReport { - #[wasm_bindgen(constructor)] - pub fn new() -> Self { - return ErrorReport { - message: String::from(""), - range: CharRange::default(), - level: ErrorLevel::default(), - }; - } -} diff --git a/src/rust/parsing/src/file.rs b/src/rust/parsing/src/file.rs index ded3783f..4d0732dd 100644 --- a/src/rust/parsing/src/file.rs +++ b/src/rust/parsing/src/file.rs @@ -128,7 +128,6 @@ use crate::error::{ Context, ErrorContext, ErrorReport, ErrorSet, ParseError, Result, ResultVec, flatten_errors, }; use crate::expression::Scope; -use crate::expression::value::{Expanding, Expression, Value}; use crate::kind::Kind; use crate::mode::{ModeInput, Modes}; use crate::{err, wrn}; @@ -465,6 +464,7 @@ pub(crate) mod tests { use crate::bind::prefix::Prefix; use crate::expression::value::Expression; use crate::expression::value::Value; + use crate::mode::WhenNoBinding; use smallvec::SmallVec; use std::collections::HashMap; use test_log::test; @@ -487,6 +487,10 @@ pub(crate) mod tests { [[define.val]] foo = "bar" + [[mode]] + name = "insert" + whenNoBinding = "insert" + [[mode]] name = "normal" default = true @@ -572,26 +576,6 @@ pub(crate) mod tests { assert_eq!(report[0].range.start.line, 0); } - #[test] - fn legacy_expression_warning() { - let data = r#" - #:master-keybindings - [header] - version = "2.0.0" - - [[bind]] - foreach.key = ['{key: [0-9]}'] - key = "a" - command = "foo{key}" - "#; - - let mut warnings = Vec::new(); - let result = parse_bytes_helper(data.as_bytes(), &mut warnings); - // let report = err.report(data.as_bytes()); - info!("warnings: {warnings:#?}"); - info!("result: {result:#?}"); - } - #[test] fn resolve_bind_and_command() { let data = r#" @@ -852,6 +836,7 @@ pub(crate) mod tests { [[mode]] name = "a" default = true + whenNoBinding = 'insert' [[mode]] name = "b" @@ -868,7 +853,7 @@ pub(crate) mod tests { .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("default mode already set")); - assert_eq!(report[0].range.start.line, 8) + assert_eq!(report[0].range.start.line, 9) } #[test] @@ -879,6 +864,7 @@ pub(crate) mod tests { [[mode]] name = "a" + whenNoBinding = 'insert' [[mode]] name = "b" @@ -934,6 +920,10 @@ pub(crate) mod tests { [header] version = "2.0.0" + [[mode]] + name = "insert" + whenNoBinding = 'insert' + [[mode]] name = "a" default = true @@ -966,6 +956,7 @@ pub(crate) mod tests { [[mode]] name = "a" default = true + whenNoBinding = 'insert' [[mode]] name = "b" @@ -982,7 +973,7 @@ pub(crate) mod tests { .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `c` is not defined")); - assert_eq!(report[0].range.start.line, 10) + assert_eq!(report[0].range.start.line, 11) } #[test] @@ -994,6 +985,7 @@ pub(crate) mod tests { [[mode]] name = "a" default = true + whenNoBinding = 'insert' [[mode]] name = "b" @@ -1037,6 +1029,7 @@ pub(crate) mod tests { [[mode]] name = "a" default = true + whenNoBinding = 'insert' [[mode]] name = "b" @@ -1060,7 +1053,7 @@ pub(crate) mod tests { .unwrap_err(); let report = err.report(data.as_bytes()); assert!(report[0].message.contains("mode `d`")); - assert_eq!(report[0].range.start.line, 17) + assert_eq!(report[0].range.start.line, 18) } fn unwrap_prefixes(prefix: &Prefix) -> &Vec { @@ -1471,6 +1464,7 @@ pub(crate) mod tests { name = "normal" default = true nme = "beep" + whenNoBinding = 'insert' [[define.google]] bob = "x" @@ -2043,6 +2037,186 @@ pub(crate) mod tests { assert_eq!(report[0].range.end.line, 9); } + #[test] + fn one_mode_must_insert() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "normal" + default = true + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings); + let report = result.unwrap_err().report(data.as_bytes()); + assert!(report[0].message.contains("`whenNoBinding='insert'`")); + assert_eq!(report[0].range.start.line, 6); + assert_eq!(report[0].range.end.line, 6); + } + + #[test] + fn mode_with_command_fallback() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "insert" + default = true + whenNoBinding = 'insert' + + [[mode]] + name = "syminsert" + highlight = "Highlight" + cursorShape = "BlockOutline" + + [[mode.whenNoBinding.run]] + command = "selection-utilities.insertAround" + args.before = "{{val.braces[captured].?before ?? captured}}" + args.after = "{{val.braces[captured].?after ?? captured}}" + args.followCursor = true + "#; + + let mut warnings = Vec::new(); + let result = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap(); + let run_commands = result.mode.map["syminsert"].whenNoBinding.clone(); + if let WhenNoBinding::Run(commands) = run_commands { + assert_eq!(commands.len(), 1); + } else { + assert!(false); + } + } + + #[test] + fn mode_with_command_has_clear_error() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "insert" + default = true + whenNoBinding = 'insert' + + [[mode]] + name = "syminsert" + highlight = "Highlight" + cursorShape = "BlockOutline" + + [[mode.whenNoBinding.run]] + args.before = "{{val.braces[captured].?before ?? captured}}" + args.after = "{{val.braces[captured].?after ?? captured}}" + args.followCursor = true + "#; + + let mut warnings = Vec::new(); + let err = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); + let report = err.report(data.as_bytes()); + assert!(report[0].message.contains("missing field")); + assert_eq!(report[0].range.start.line, 16); + assert_eq!(report[0].range.end.line, 16); + } + + #[test] + fn mode_with_wrong_object_has_clear_error() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "insert" + default = true + whenNoBinding = 'insert' + + [[mode]] + name = "syminsert" + highlight = "Highlight" + cursorShape = "BlockOutline" + + [[mode.whenNoBinding.rub]] + args.before = "{{val.braces[captured].?before ?? captured}}" + args.after = "{{val.braces[captured].?after ?? captured}}" + args.followCursor = true + "#; + + let mut warnings = Vec::new(); + let err = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("`rub`")); + assert_eq!(report[0].range.start.line, 16); + assert_eq!(report[0].range.end.line, 16); + } + + #[test] + fn mode_with_wrong_when_binding_string_has_clear_error() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "insert" + default = true + whenNoBinding = 'insert' + + [[mode]] + name = "syminsert" + highlight = "Highlight" + cursorShape = "BlockOutline" + whenNoBinding = 'insrt' + "#; + + let mut warnings = Vec::new(); + let err = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("insrt")); + assert_eq!(report[0].range.start.line, 15); + assert_eq!(report[0].range.end.line, 15); + } + + #[test] + fn mode_with_extra_when_binding_key_fails() { + let data = r#" + #:master-keybindings + + [header] + version = "2.0.0" + + [[mode]] + name = "insert" + default = true + whenNoBinding = 'insert' + + [[mode]] + name = "syminsert" + highlight = "Highlight" + cursorShape = "BlockOutline" + whenNoBinding.useMode = "insert" + whenNoBinding.x = "foo" + "#; + + let mut warnings = Vec::new(); + let err = parse_bytes_helper(data.as_bytes(), &mut warnings).unwrap_err(); + let report = err.report(data.as_bytes()); + + assert!(report[0].message.contains("`x`")); + assert_eq!(report[0].range.start.line, 15); + assert_eq!(report[0].range.end.line, 15); + } + // TODO: write a test for required field `key` and ensure the span // is narrowed to the appropriate `[[bind]]` element; also should only error once // (right now we're erroring on the expanded value) diff --git a/src/rust/parsing/src/mode.rs b/src/rust/parsing/src/mode.rs index b58c2ae1..3280c43f 100644 --- a/src/rust/parsing/src/mode.rs +++ b/src/rust/parsing/src/mode.rs @@ -93,9 +93,9 @@ pub struct ModeInput { /// explicitly define a mode /// - `"insert"`: The keys should insert text. This is true for the implicitly defined /// "default" mode. - /// - `"useMode": "[mode]"`: fallback to the keybindings defined for another mode - /// - `"run": | []`: set `key.capture` to a string representing - /// the key pressed and run the given command or commands, as per the fields allowed + /// - `{"useMode": "[mode]"}`: fallback to the keybindings defined for another mode + /// - `{"run": []}`: set `key.capture` to a string representing + /// the key pressed and run the given commands, as per the fields allowed /// when [running multiple commands](#running-multiple-commands) in `[[bind]]`. #[serde(default)] whenNoBinding: Option>, @@ -117,14 +117,93 @@ impl Default for ModeInput { } } -#[derive(Clone, Debug, Deserialize, Default)] -#[serde(rename_all = "camelCase")] +#[derive(Clone, Debug, Default)] pub enum WhenNoBindingInput { #[default] Ignore, Insert, UseMode(String), - Run(Plural), + Run(Vec), +} + +impl<'de> serde::de::Deserialize<'de> for WhenNoBindingInput { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + // Define a visitor struct + struct WhenNoBindingInputVisitor; + + impl<'de> serde::de::Visitor<'de> for WhenNoBindingInputVisitor { + type Value = WhenNoBindingInput; + + // This is our main custom error message! + fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { + formatter.write_str( + "a string ('ignore' or 'insert') or a single-key object ('useMode: ' or 'run: []')", + ) + } + + // Handles the unit variants: "ignore" and "insert" + fn visit_str(self, v: &str) -> std::result::Result + where + E: serde::de::Error, + { + match v { + "ignore" => Ok(WhenNoBindingInput::Ignore), + "insert" => Ok(WhenNoBindingInput::Insert), + other => Err(serde::de::Error::custom(format_args!( + "unexpected string value '{}', expected 'ignore' or 'insert'", + other + ))), + } + } + + // Handles the newtype variants: UseMode(String) and Run(...) + fn visit_map(self, mut map: A) -> std::result::Result + where + A: serde::de::MapAccess<'de>, + { + // We expect exactly one key + let key: String = match map.next_key()? { + Some(key) => key, + Option::None => { + return Err(serde::de::Error::custom( + "expected object with one key ('useMode' or 'run'), but got empty object", + )); + } + }; + + // Deserialize the value based on the key + let result = match key.as_str() { + "useMode" => { + let val = map.next_value::()?; + Ok(WhenNoBindingInput::UseMode(val)) + } + "run" => { + let val = map.next_value::>()?; + Ok(WhenNoBindingInput::Run(val)) + } + other => Err(serde::de::Error::custom(format_args!( + "unknown key `{other}`, expected 'useMode' or 'run'", + ))), + }?; + + // Check for any extra keys, which is an error + if let Some(next_key) = map.next_key::()? { + return Err(serde::de::Error::custom(format_args!( + "expected object with only one key but found extra key `{next_key}`", + ))); + } + + Ok(result) + } + } + + // Tell Serde we can deserialize from *either* a string or a map. + // `deserialize_any` will call the appropriate visitor method. + deserializer.deserialize_any(WhenNoBindingInputVisitor) + } } impl LeafValue for WhenNoBindingInput {} @@ -221,7 +300,7 @@ impl Mode { #[derive(Serialize, Clone, Debug)] #[wasm_bindgen(getter_with_clone)] pub struct Modes { - map: HashMap, + pub(crate) map: HashMap, pub default: String, } @@ -312,6 +391,18 @@ impl Modes { warnings.append(&mut mode_warnings) } + // validate that at least one mode allows the user to type keys + if !modes + .iter() + .any(|(_, m)| m.whenNoBinding == WhenNoBinding::Insert) + { + Err(err( + "`whenNoBinding='insert'` must be set for at least one mode; \ + otherwise the user cannot type", + )) + .with_range(&first_mode_span)? + } + return Ok(Modes { map: modes, default: default_mode.unwrap(), diff --git a/src/rust/parsing/src/util.rs b/src/rust/parsing/src/util.rs index dde0d80b..551c6381 100644 --- a/src/rust/parsing/src/util.rs +++ b/src/rust/parsing/src/util.rs @@ -4,7 +4,7 @@ use log::info; use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use std::collections::HashMap; -use toml::{Spanned, Value}; +use toml::Spanned; use crate::bind::UNKNOWN_RANGE; use crate::err; @@ -221,22 +221,6 @@ impl Merging for String { // } // } -// -// ---------------- Subset ---------------- -// - -pub enum Subset { - Some(Vec), - AllBut(Vec), - All, -} - -impl From> for Subset { - fn from(value: Vec) -> Subset { - return Subset::Some(value); - } -} - // // ---------------- Resolving ---------------- //